AsyncTask.executeOnExecutor () antes del nivel 11 de la API

La forma normal en que hacemos AsyncTask en Android es, desde Android API:

private class DoIntenseTask extends AsyncTask { protected Void doInBackground(Object... params) { for (Object param : params) { Object rtnObj = doIntenseJob(param); publishProgress(rtnObj); } return null; } protected void onProgressUpdate(Object... progress) { for (Object rtnObj : progress) { updateActivityUI(rtnObj); } } } 

Mis tareas intensas están ligeramente acopladas y el orden de ejecución no importa, al hacer esto, se asigna un único hilo para ejecutar una lista de tareas intensas. personalmente, creo que esto es una especie de solución a medio camino. Sí, el trabajo intenso ya no se ejecuta en el hilo de la interfaz de usuario, pero aún debe ejecutarse uno por uno (en muchos casos, enfrentamos una lista de trabajo intenso, creo que también es por eso que los métodos en AsyncTask tienen múltiples parámetros). Google debería hacer que la API sea más reutilizable para resolver diferentes tipos de escenarios.

Lo que realmente me gusta es ejecutar un número de doIntenseJob () en paralelo administrado por un threadpool (por ejemplo, poolSize = 5). Parece que Google da una solución por AsyncTask.executeOnExecutor () pero desafortunadamente solo está disponible desde el nivel 11 de la API. Estoy desarrollando aplicaciones en dispositivos móviles y me pregunto si hay una solución que pueda lograr el mismo comportamiento bajo el nivel API 11.

Gracias por adelantado
Y

Mis tareas intensas están ligeramente acopladas y el orden de ejecución no importa, al hacer esto, se asigna un único hilo para ejecutar una lista de tareas intensas.

AsyncTask actualmente usa un grupo de subprocesos con varios subprocesos. En el futuro, puede estar restringido a un solo hilo: Google ha insinuado que este será el caso.

Me pregunto si hay una solución que puedo lograr el mismo comportamiento bajo el nivel API 11.

El comportamiento predeterminado es el comportamiento que desea. Si examina el código fuente de AsyncTask , verá que a partir de Gingerbread, utilizó un grupo de subprocesos con un mínimo de 5 subprocesos y un máximo de 128.

Ahora, tenga en cuenta que la gran mayoría de los dispositivos Android actualmente en uso son de un solo núcleo. Por lo tanto, a menos que sus “tareas intensas” no hagan mucho pero bloqueen la E / S de red, no querrá hacerlas en paralelo, ya que el cambio de contexto entre hilos simplemente lo ralentizará aún más.

Si su objective de comstackción está configurado en el Nivel 11 de la API o superior, y desea utilizar específicamente tareas paralelas, querrá comenzar a indicarlo explícitamente en su código, similar a:

 if (Build.VERSION.SDK_INT>=Build.VERSION_CODES.HONEYCOMB) { myTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void[]) null); } else { myTask.execute((Void) null); } 

http://commonsware.com/blog/2012/04/20/asynctask-threading-regression-confirmed.html

Ha pasado mucho tiempo desde que hice esta pregunta, de tanto en tanto, puedo encontrar una pregunta similar en StackOverflow que termina sin una respuesta sólida, por lo que decido estudiar un poco más y tratar de responderla yo mismo.

Algo que debo señalar primero es que en la mayoría de los casos, el comportamiento predeterminado de la implementación de subprocesos subyacentes viene con AsyncTask API es suficiente y no es necesario alterarlo utilizando AsyncTask.executeOnExecutor () especialmente cuando apuntas a una versión anterior antes de HoneyComb , que ya ha declarado en la respuesta de CommonsWare. Sin embargo, si necesita controlar bien el subprocesamiento de subprocesos en la versión anterior de SDK utilizando AsyncTask.executeOnExecutor (), aquí está la respuesta que puede interesarle.

En términos generales, mi solución es simplemente copiar la nueva versión de AsyncTask (desde API Nivel 11) en nuestra propia implementación AsyncTask y hacer que funcione con anterior SDK de Android (hasta API nivel 3). Primero, lea el código fuente de AsyncTask aquí y asegúrese de tener una idea básica de cómo se implementa.

A partir del código fuente, puede ver que casi todas las clases importadas y utilizadas por AsyncTask se introducen desde el nivel 1 de API, es decir, todas las clases desde java.util.concurrent. * Más otras tres (Handler, Message y Process) desde android.os . *, el único excepto java.util.ArrayDeque que se introduce en Android SDK desde API Nivel 9. ArrayDeque solo se utiliza para implementar uno de los ejecutores predeterminados. SERIAL_EXECUTOR vino con AsyncTask, para hacer que nuestro AsyncTask.executeOnExecutor () esté disponible en versiones antiguas Android SDK, simple eliminación SERIAL_EXECUTOR implementación desde el código fuente, el mismo comportamiento se puede lograr mediante el uso de SingleThreadPoolExecutor.

El código fuente modificado se adjunta al final (probado en Gingerbread). Lo que debe hacer ahora es extenderle AsyncTask desde este ejemplo.ejemplo.AsyncTask en lugar de android.os.AsyncTask, que admite AsyncTask.executeOnExecutor () hasta el nivel 3 de la API.

 package com.example; /* * Copyright (C) 2008 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ //import java.util.ArrayDeque; import java.util.concurrent.BlockingQueue; import java.util.concurrent.Callable; import java.util.concurrent.CancellationException; import java.util.concurrent.Executor; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.ThreadFactory; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; import android.os.Handler; import android.os.Message; import android.os.Process; /** * ### I delete this comments as it make the answer too long to submit ### */ public abstract class AsyncTask { private static final String LOG_TAG = "AsyncTask"; private static final int CORE_POOL_SIZE = 5; private static final int MAXIMUM_POOL_SIZE = 128; private static final int KEEP_ALIVE = 1; private static final ThreadFactory sThreadFactory = new ThreadFactory() { private final AtomicInteger mCount = new AtomicInteger(1); public Thread newThread(Runnable r) { return new Thread(r, "AsyncTask #" + mCount.getAndIncrement()); } }; private static final BlockingQueue sPoolWorkQueue = new LinkedBlockingQueue(10); /** * An {@link Executor} that can be used to execute tasks in parallel. */ public static final Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory); /** * An {@link Executor} that executes tasks one at a time in serial * order. This serialization is global to a particular process. */ // public static final Executor SERIAL_EXECUTOR = new SerialExecutor(); private static final int MESSAGE_POST_RESULT = 0x1; private static final int MESSAGE_POST_PROGRESS = 0x2; private static final InternalHandler sHandler = new InternalHandler(); // private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR; private static volatile Executor sDefaultExecutor = THREAD_POOL_EXECUTOR; private final WorkerRunnable mWorker; private final FutureTask mFuture; private volatile Status mStatus = Status.PENDING; private final AtomicBoolean mTaskInvoked = new AtomicBoolean(); // private static class SerialExecutor implements Executor { // final ArrayDeque mTasks = new ArrayDeque(); // Runnable mActive; // // public synchronized void execute(final Runnable r) { // mTasks.offer(new Runnable() { // public void run() { // try { // r.run(); // } finally { // scheduleNext(); // } // } // }); // if (mActive == null) { // scheduleNext(); // } // } // // protected synchronized void scheduleNext() { // if ((mActive = mTasks.poll()) != null) { // THREAD_POOL_EXECUTOR.execute(mActive); // } // } // } /** * Indicates the current status of the task. Each status will be set only once * during the lifetime of a task. */ public enum Status { /** * Indicates that the task has not been executed yet. */ PENDING, /** * Indicates that the task is running. */ RUNNING, /** * Indicates that {@link AsyncTask#onPostExecute} has finished. */ FINISHED, } /** @hide Used to force static handler to be created. */ public static void init() { sHandler.getLooper(); } /** @hide */ public static void setDefaultExecutor(Executor exec) { sDefaultExecutor = exec; } /** * Creates a new asynchronous task. This constructor must be invoked on the UI thread. */ public AsyncTask() { mWorker = new WorkerRunnable() { public Result call() throws Exception { mTaskInvoked.set(true); Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); return postResult(doInBackground(mParams)); } }; mFuture = new FutureTask(mWorker) { @Override protected void done() { try { final Result result = get(); postResultIfNotInvoked(result); } catch (InterruptedException e) { android.util.Log.w(LOG_TAG, e); } catch (ExecutionException e) { throw new RuntimeException("An error occured while executing doInBackground()", e.getCause()); } catch (CancellationException e) { postResultIfNotInvoked(null); } catch (Throwable t) { throw new RuntimeException("An error occured while executing " + "doInBackground()", t); } } }; } private void postResultIfNotInvoked(Result result) { final boolean wasTaskInvoked = mTaskInvoked.get(); if (!wasTaskInvoked) { postResult(result); } } private Result postResult(Result result) { Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult(this, result)); message.sendToTarget(); return result; } /** * Returns the current status of this task. * * @return The current status. */ public final Status getStatus() { return mStatus; } /** * Override this method to perform a computation on a background thread. The * specified parameters are the parameters passed to {@link #execute} * by the caller of this task. * * This method can call {@link #publishProgress} to publish updates * on the UI thread. * * @param params The parameters of the task. * * @return A result, defined by the subclass of this task. * * @see #onPreExecute() * @see #onPostExecute * @see #publishProgress */ protected abstract Result doInBackground(Params... params); /** * Runs on the UI thread before {@link #doInBackground}. * * @see #onPostExecute * @see #doInBackground */ protected void onPreExecute() { } /** * 

Runs on the UI thread after {@link #doInBackground}. The * specified result is the value returned by {@link #doInBackground}.

* *

This method won't be invoked if the task was cancelled.

* * @param result The result of the operation computed by {@link #doInBackground}. * * @see #onPreExecute * @see #doInBackground * @see #onCancelled(Object) */ @SuppressWarnings({"UnusedDeclaration"}) protected void onPostExecute(Result result) { } /** * Runs on the UI thread after {@link #publishProgress} is invoked. * The specified values are the values passed to {@link #publishProgress}. * * @param values The values indicating progress. * * @see #publishProgress * @see #doInBackground */ @SuppressWarnings({"UnusedDeclaration"}) protected void onProgressUpdate(Progress... values) { } /** *

Runs on the UI thread after {@link #cancel(boolean)} is invoked and * {@link #doInBackground(Object[])} has finished.

* *

The default implementation simply invokes {@link #onCancelled()} and * ignores the result. If you write your own implementation, do not call * super.onCancelled(result).

* * @param result The result, if any, computed in * {@link #doInBackground(Object[])}, can be null * * @see #cancel(boolean) * @see #isCancelled() */ @SuppressWarnings({"UnusedParameters"}) protected void onCancelled(Result result) { onCancelled(); } /** *

Applications should preferably override {@link #onCancelled(Object)}. * This method is invoked by the default implementation of * {@link #onCancelled(Object)}.

* *

Runs on the UI thread after {@link #cancel(boolean)} is invoked and * {@link #doInBackground(Object[])} has finished.

* * @see #onCancelled(Object) * @see #cancel(boolean) * @see #isCancelled() */ protected void onCancelled() { } /** * Returns true if this task was cancelled before it completed * normally. If you are calling {@link #cancel(boolean)} on the task, * the value returned by this method should be checked periodically from * {@link #doInBackground(Object[])} to end the task as soon as possible. * * @return true if task was cancelled before it completed * * @see #cancel(boolean) */ public final boolean isCancelled() { return mFuture.isCancelled(); } /** *

Attempts to cancel execution of this task. This attempt will * fail if the task has already completed, already been cancelled, * or could not be cancelled for some other reason. If successful, * and this task has not started when cancel is called, * this task should never run. If the task has already started, * then the mayInterruptIfRunning parameter determines * whether the thread executing this task should be interrupted in * an attempt to stop the task.

* *

Calling this method will result in {@link #onCancelled(Object)} being * invoked on the UI thread after {@link #doInBackground(Object[])} * returns. Calling this method guarantees that {@link #onPostExecute(Object)} * is never invoked. After invoking this method, you should check the * value returned by {@link #isCancelled()} periodically from * {@link #doInBackground(Object[])} to finish the task as early as * possible.

* * @param mayInterruptIfRunning true if the thread executing this * task should be interrupted; otherwise, in-progress tasks are allowed * to complete. * * @return false if the task could not be cancelled, * typically because it has already completed normally; * true otherwise * * @see #isCancelled() * @see #onCancelled(Object) */ public final boolean cancel(boolean mayInterruptIfRunning) { return mFuture.cancel(mayInterruptIfRunning); } /** * Waits if necessary for the computation to complete, and then * retrieves its result. * * @return The computed result. * * @throws CancellationException If the computation was cancelled. * @throws ExecutionException If the computation threw an exception. * @throws InterruptedException If the current thread was interrupted * while waiting. */ public final Result get() throws InterruptedException, ExecutionException { return mFuture.get(); } /** * Waits if necessary for at most the given time for the computation * to complete, and then retrieves its result. * * @param timeout Time to wait before cancelling the operation. * @param unit The time unit for the timeout. * * @return The computed result. * * @throws CancellationException If the computation was cancelled. * @throws ExecutionException If the computation threw an exception. * @throws InterruptedException If the current thread was interrupted * while waiting. * @throws TimeoutException If the wait timed out. */ public final Result get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { return mFuture.get(timeout, unit); } /** * Executes the task with the specified parameters. The task returns * itself (this) so that the caller can keep a reference to it. * *

Note: this function schedules the task on a queue for a single background * thread or pool of threads depending on the platform version. When first * introduced, AsyncTasks were executed serially on a single background thread. * Starting with {@link android.os.Build.VERSION_CODES#DONUT}, this was changed * to a pool of threads allowing multiple tasks to operate in parallel. After * {@link android.os.Build.VERSION_CODES#HONEYCOMB}, it is planned to change this * back to a single thread to avoid common application errors caused * by parallel execution. If you truly want parallel execution, you can use * the {@link #executeOnExecutor} version of this method * with {@link #THREAD_POOL_EXECUTOR}; however, see commentary there for warnings on * its use. * *

This method must be invoked on the UI thread. * * @param params The parameters of the task. * * @return This instance of AsyncTask. * * @throws IllegalStateException If {@link #getStatus()} returns either * {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}. */ public final AsyncTask execute(Params... params) { return executeOnExecutor(sDefaultExecutor, params); } /** * Executes the task with the specified parameters. The task returns * itself (this) so that the caller can keep a reference to it. * *

This method is typically used with {@link #THREAD_POOL_EXECUTOR} to * allow multiple tasks to run in parallel on a pool of threads managed by * AsyncTask, however you can also use your own {@link Executor} for custom * behavior. * *

Warning: Allowing multiple tasks to run in parallel from * a thread pool is generally not what one wants, because the order * of their operation is not defined. For example, if these tasks are used * to modify any state in common (such as writing a file due to a button click), * there are no guarantees on the order of the modifications. * Without careful work it is possible in rare cases for the newer version * of the data to be over-written by an older one, leading to obscure data * loss and stability issues. Such changes are best * executed in serial; to guarantee such work is serialized regardless of * platform version you can use this function with {@link #SERIAL_EXECUTOR}. * *

This method must be invoked on the UI thread. * * @param exec The executor to use. {@link #THREAD_POOL_EXECUTOR} is available as a * convenient process-wide thread pool for tasks that are loosely coupled. * @param params The parameters of the task. * * @return This instance of AsyncTask. * * @throws IllegalStateException If {@link #getStatus()} returns either * {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}. */ public final AsyncTask executeOnExecutor(Executor exec, Params... params) { if (mStatus != Status.PENDING) { switch (mStatus) { case RUNNING: throw new IllegalStateException("Cannot execute task:" + " the task is already running."); case FINISHED: throw new IllegalStateException("Cannot execute task:" + " the task has already been executed " + "(a task can be executed only once)"); } } mStatus = Status.RUNNING; onPreExecute(); mWorker.mParams = params; exec.execute(mFuture); return this; } /** * Convenience version of {@link #execute(Object...)} for use with * a simple Runnable object. */ public static void execute(Runnable runnable) { sDefaultExecutor.execute(runnable); } /** * This method can be invoked from {@link #doInBackground} to * publish updates on the UI thread while the background computation is * still running. Each call to this method will trigger the execution of * {@link #onProgressUpdate} on the UI thread. * * {@link #onProgressUpdate} will note be called if the task has been * canceled. * * @param values The progress values to update the UI with. * * @see #onProgressUpdate * @see #doInBackground */ protected final void publishProgress(Progress... values) { if (!isCancelled()) { sHandler.obtainMessage(MESSAGE_POST_PROGRESS, new AsyncTaskResult(this, values)).sendToTarget(); } } private void finish(Result result) { if (isCancelled()) { onCancelled(result); } else { onPostExecute(result); } mStatus = Status.FINISHED; } private static class InternalHandler extends Handler { @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"}) @Override public void handleMessage(Message msg) { AsyncTaskResult result = (AsyncTaskResult) msg.obj; switch (msg.what) { case MESSAGE_POST_RESULT: // There is only one result result.mTask.finish(result.mData[0]); break; case MESSAGE_POST_PROGRESS: result.mTask.onProgressUpdate(result.mData); break; } } } private static abstract class WorkerRunnable implements Callable { Params[] mParams; } @SuppressWarnings({"RawUseOfParameterizedType"}) private static class AsyncTaskResult { final AsyncTask mTask; final Data[] mData; AsyncTaskResult(AsyncTask task, Data... data) { mTask = task; mData = data; } } }

Creé una clase de ayuda abstracta para determinar el número de comstackción y selecciono ejecutar o ejecutar correctamente Exencocutor. Parece que funciona bastante bien

 public abstract class MyAsyncTask extends AsyncTask { public void executeContent(T... content) { if (Build.VERSION.SDK_INT>=Build.VERSION_CODES.HONEYCOMB) { this.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, content); } else { this.execute(content); } } } 

implementación del ejemplo de clase abstracta:

  public class MyTask extends MyAsyncTask { @Override protected Void doInBackground(String... params) { //do work return null; } } 

creando instancia de clase

  new MyTask().executeContent("go"); 

En la biblioteca de compatibilidad existe un AsyncTaskCompat. Esta clase contiene un método estático executeInParallel.

Este método es igual al método executeOrExecutor, puede usar este método con la API 4

Vea un ejemplo para usar esto:

 AsyncTaskCompat.executeParallel(new AsyncTask() { @Override protected Bitmap doInBackground(Void... params) { return MediaStore.Images.Thumbnails.getThumbnail( imageView.getContext().getContentResolver(), id, MediaStore.Images.Thumbnails.MINI_KIND, null); } @Override protected void onPostExecute(Bitmap bitmap) { imageView.setImageBitmap(bitmap); if (bitmap != null) { // Add the image to the memory cache first CACHE.put(id, bitmap); if (listener != null) { listener.onImageLoaded(bitmap); } } } }); 

disfrutar