AsyncTask.executeOnExecutor () avant l'API niveau 11
La façon normale dont nous faisons AsyncTask dans Android est, de Android API:
private class DoIntenseTask extends AsyncTask<Object, Object, Void> {
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);
}
}
}
Mes tâches intenses sont faiblement couplées et l'ordre d'exécution n'a pas d'importance, en procédant ainsi, un seul thread est alloué pour exécuter une liste de tâches intenses. personnellement, je pense que c'est une sorte de solution à mi-chemin. Oui, le travail intense ne s'exécute plus dans le thread d'interface utilisateur, mais doit toujours être exécuté un par un (dans de nombreux cas, nous sommes confrontés à une liste de travail intense, je pense que c'est aussi pourquoi les méthodes d'AsyncTask sont multi-paramétrées). Google devrait rendre l'API plus réutilisable pour résoudre différents types de scénarios.
Ce que j'aime vraiment, c'est exécuter un certain nombre de doIntenseJob () en parallèle gérés par un pool de threads (par exemple poolSize = 5). On dirait que Google donne une solution par AsyncTask.executeOnExecutor () mais malheureusement uniquement disponible depuis l'API niveau 11. Je développe une application sur mobile et je me demande s'il existe une solution de contournement pour que je puisse obtenir le même comportement sous API niveau 11.
Merci d'avance
O
Mes tâches intenses sont faiblement couplées et l'ordre d'exécution n'a pas d'importance, en procédant ainsi, un seul thread est alloué pour exécuter une liste de tâches intenses.
AsyncTask utilise actuellement un pool de threads avec plusieurs threads. À l'avenir, il pourrait être limité à un seul fil - Google a laissé entendre que ce serait le cas.
me demande s'il existe une solution de contournement pour que je puisse obtenir le même comportement sous API niveau 11.
Le comportement par défaut est celui que vous souhaitez. Si vous examinez le code source de AsyncTask , vous verrez qu'à partir de Gingerbread, il utilisait un pool de threads avec un minimum de 5 threads et un maximum de 128.
Maintenant, gardez à l'esprit que la grande majorité des Android Android utilisés aujourd'hui sont monocœurs. Par conséquent, à moins que vos "tâches intenses" ne font pas grand chose mais bloquent les E/S réseau, vous ne voulez pas les faire en parallèle, car les changements de contexte entre les threads vous ralentiront simplement.
Si votre cible de génération est définie sur le niveau d'API 11 ou supérieur et que vous souhaitez utiliser spécifiquement des tâches parallèles, vous souhaiterez commencer à l'indiquer explicitement dans votre code, comme:
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
Cela fait longtemps que je n'ai pas posé cette question, de temps en temps, je peux trouver une question similaire posée dans StackOverflow se terminant sans réponse solide, donc je décide de faire une étude plus approfondie et d'essayer d'y répondre moi-même.
Une chose que je dois souligner en premier est dans la plupart des cas courants, le comportement par défaut de l'implémentation sous-jacente de pool de threads fourni avec l'API AsyncTask est suffisant et il n'est pas nécessaire de le modifier en utilisant AsyncTask.executeOnExecutor () en particulier lorsque vous ciblez une version antérieure à HoneyComb , qui a déjà déclaré dans la réponse de CommonsWare. Cependant, si vous avez besoin de contrôler avec précision le pool de threads sous-jacent sur la version antérieure du SDK en utilisant AsyncTask.executeOnExecutor (), voici la réponse qui pourrait vous intéresser.
De manière générale, ma solution consiste simplement à copier la nouvelle version d'AsyncTask (à partir de l'API niveau 11) dans notre propre implémentation AsyncTask et à la faire fonctionner avec une version antérieure Android SDK (jusqu'à l'API niveau 3). , lisez le code source AsyncTask ici et assurez-vous d'avoir une idée de base de la façon dont il est implémenté.
À partir du code source, vous pouvez voir que presque toutes les classes importées et utilisées par AsyncTask sont introduites depuis le niveau 1 de l'API, c'est-à-dire toutes les classes de Java.util.concurrent. * Plus les trois autres (gestionnaire, message et processus) d'Android.os . *, le seul sauf est Java.util.ArrayDeque qui est introduit dans Android SDK depuis le niveau d'API 9. ArrayDeque n'est utilisé que pour implémenter l'un des exécuteurs par défaut SERIAL_EXECUTOR est venu avec AsyncTask, pour rendre notre AsyncTask.executeOnExecutor () disponible sur l'ancien Android SDK, simple suppression de l'implémentation SERIAL_EXECUTOR du code source, le même comportement peut être obtenu par en utilisant singleThreadPoolExecutor.
Le code source modifié est joint à la fin (testé sur Gingerbread). Ce que vous devez faire maintenant, c'est étendre AsyncTask de ce com.example.AsyncTask au lieu d'Android.os.AsyncTask, qui prend en charge AsyncTask.executeOnExecutor () jusqu'au niveau API 3.
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<Params, Progress, Result> {
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<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(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<Params, Result> mWorker;
private final FutureTask<Result> mFuture;
private volatile Status mStatus = Status.PENDING;
private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
// private static class SerialExecutor implements Executor {
// final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
// 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<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
return postResult(doInBackground(mParams));
}
};
mFuture = new FutureTask<Result>(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<Result>(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() {
}
/**
* <p>Runs on the UI thread after {@link #doInBackground}. The
* specified result is the value returned by {@link #doInBackground}.</p>
*
* <p>This method won't be invoked if the task was cancelled.</p>
*
* @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) {
}
/**
* <p>Runs on the UI thread after {@link #cancel(boolean)} is invoked and
* {@link #doInBackground(Object[])} has finished.</p>
*
* <p>The default implementation simply invokes {@link #onCancelled()} and
* ignores the result. If you write your own implementation, do not call
* <code>super.onCancelled(result)</code>.</p>
*
* @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();
}
/**
* <p>Applications should preferably override {@link #onCancelled(Object)}.
* This method is invoked by the default implementation of
* {@link #onCancelled(Object)}.</p>
*
* <p>Runs on the UI thread after {@link #cancel(boolean)} is invoked and
* {@link #doInBackground(Object[])} has finished.</p>
*
* @see #onCancelled(Object)
* @see #cancel(boolean)
* @see #isCancelled()
*/
protected void onCancelled() {
}
/**
* Returns <tt>true</tt> 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 <tt>true</tt> if task was cancelled before it completed
*
* @see #cancel(boolean)
*/
public final boolean isCancelled() {
return mFuture.isCancelled();
}
/**
* <p>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 <tt>cancel</tt> is called,
* this task should never run. If the task has already started,
* then the <tt>mayInterruptIfRunning</tt> parameter determines
* whether the thread executing this task should be interrupted in
* an attempt to stop the task.</p>
*
* <p>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.</p>
*
* @param mayInterruptIfRunning <tt>true</tt> if the thread executing this
* task should be interrupted; otherwise, in-progress tasks are allowed
* to complete.
*
* @return <tt>false</tt> if the task could not be cancelled,
* typically because it has already completed normally;
* <tt>true</tt> 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.
*
* <p>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.
*
* <p>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<Params, Progress, Result> 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.
*
* <p>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.
*
* <p><em>Warning:</em> Allowing multiple tasks to run in parallel from
* a thread pool is generally <em>not</em> 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}.
*
* <p>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<Params, Progress, Result> 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<Progress>(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<Params, Result> implements Callable<Result> {
Params[] mParams;
}
@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
}
J'ai créé une classe d'assistance abstraite pour déterminer le numéro de build et choisir exécuter ou executeOnExecutor de manière appropriée. Cela semble assez bien fonctionner
public abstract class MyAsyncTask<T, V, Q> extends AsyncTask<T, V, Q> {
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);
}
}
}
implémentation d'un exemple de classe abstraite:
public class MyTask extends MyAsyncTask<String, Void, Void> {
@Override
protected Void doInBackground(String... params) {
//do work
return null;
}
}
création d'une instance de classe
new MyTask().executeContent("go");
Dans la bibliothèque de compatibilité existe un AsyncTaskCompat. Cette classe contient une méthode statique executeInParallel.
Cette méthode est égale à la méthode executeOrExecutor, vous pouvez utiliser cette méthode avec l'API 4
Voir un exemple d'utilisation de ceci:
AsyncTaskCompat.executeParallel(new AsyncTask<Void, Void, Bitmap>() {
@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);
}
}
}
});
prendre plaisir