API 级别 11 之前的 AsyncTask.executeOnExecutor()
Posted
技术标签:
【中文标题】API 级别 11 之前的 AsyncTask.executeOnExecutor()【英文标题】：AsyncTask.executeOnExecutor() before API Level 11 【发布时间】：2011-11-04 21:59:56 【问题描述】：我们在 android 中执行 AsyncTask 的正常方式是，来自 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);
我的密集任务是松耦合的，执行顺序无关紧要，通过这种方式，分配一个线程来运行一系列密集任务。我个人认为这是一种半途而废的解决方案。是的，紧张的工作不再在UI线程中运行，但仍然需要一个接一个地执行（在很多情况下，我们面临着一个密集的工作列表，我想这也是为什么AsyncTask中的方法是多参数化的）。谷歌应该使 API 更可重用以解决不同类型的场景。
我真正喜欢的是并行运行多个由线程池管理的 doIntenseJob()（例如 poolSize = 5）。看起来谷歌确实通过 AsyncTask.executeOnExecutor() 提供了一个解决方案，但不幸的是，自 API 级别 11 起才可用。我正在开发移动应用程序，想知道是否有一种解决方法可以在 API 级别 11 下实现相同的行为。
提前致谢 是的
【问题讨论】：
【参考方案1】：如果您的构建目标设置为 API 级别 11 或更高，并且您想专门使用并行任务，您将需要开始在代码中明确说明这一点，类似于：
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
【讨论】：
我面临同样的问题，请帮我解决这个问题.. \ @Vaishali 您正在使用这些行运行 AsyncTasck 替代任务执行，请参阅更新的答案【参考方案2】：很久没问这个问题了，时不时能在***中找到类似的问题，但最终没有确定的答案，所以我决定做一些进一步的研究，并尝试自己回答。
我首先要指出的一点是，在最常见的情况下，AsyncTask API 附带的底层线程池实现的默认行为就足够了，没有必要通过使用 AsyncTask.executeOnExecutor() 来更改它，尤其是当您针对较早的目标时HoneyComb 之前的版本，这已经在 CommonsWare 的回答中说明了。但是，如果您确实需要使用 AsyncTask.executeOnExecutor() 对早期版本的 SDK 上的底层线程池进行精细控制，这里是您可能感兴趣的答案。
一般来说，我的解决方案只是将新版本的 AsyncTask（从 API 级别 11）复制到我们自己的 AsyncTask 实现中，并使其与早期的 Android SDK（低至 API 级别 3）一起使用。首先，阅读 AsyncTask 源代码here 并确保您对它的实现方式有一个基本的了解。
从源码中可以看出，AsyncTask 导入和使用的类几乎都是从 API 级别 1 开始引入的，即所有来自 java.util.concurrent.* 的类加上其他三个（Handler、Message 和 Process）来自android.os.*，唯一的例外是java.util.ArrayDeque，它自 API 级别 9 起被引入 Android SDK。ArrayDeque 仅用于实现 AsyncTask 附带的默认执行程序之一SERIAL_EXECUTOR，以使我们的 AsyncTask.executeOnExecutor()在旧的 Android SDK 上可用，只需从源代码中删除 SERIAL_EXECUTOR 实现，使用 singleThreadPoolExecutor 即可实现相同的行为。
最后附上修改后的源代码（在 Gingerbread 上测试）。您现在需要做的是从这个 com.example.AsyncTask 扩展您的 AsyncTask，而不是 android.os.AsyncTask，后者支持 AsyncTask.executeOnExecutor() 到 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;
【讨论】：
从 SerialExecutor（在新的 AsyncTask 中实现）而不是使用简单的新 ThreadPoolExecutor(1, 1, KEEP_ALIVE, TimeUnit.SECONDS, sPoolWorkQueue); ? @StErMi，严格来说，没有任何改变，在默认的Android实现中，SERIAL_EXECUTOR确实重用了THREAD_POOL_EXECUTOR来执行任务，额外控制下一个任务何时提交，我已经解释了更多@987654324 @. 如果我在我的项目中使用上面的代码（重命名为 SerialAsyncTask）并将 CORE_POOL_SIZE 和 MAXIMUM_POOL_SIZE 设置为 1，我的 SerialAsyncTask 将连续运行，我是否正确？ （我认为这是 StErMi 提出的问题，但我只是想仔细检查一下）【参考方案3】：我的密集任务是松散耦合的，执行顺序无关紧要，通过这种方式，分配一个线程来运行一系列密集任务。
AsyncTask 目前使用具有多个线程的线程池。将来，它可能会被限制在一个线程上——Google 已经暗示会是这样。
想知道是否有一种解决方法可以在 API 级别 11 下实现相同的行为。
默认行为是您想要的行为。如果您检查the source code to AsyncTask，您会发现，从 Gingerbread 开始，它使用的线程池最少有 5 个线程，最多有 128 个线程。
现在，请记住，当今使用的大多数 Android 设备都是单核的。因此，除非您的“高强度任务”没有做太多工作而是阻塞网络 I/O，否则您不希望并行执行它们，因为线程之间的上下文切换只会进一步减慢您的速度。
【讨论】：
根据源代码，看起来如果我从 doInBackground() 中取出 for 循环并在 UI 线程中调用一堆新的 DoIntenseTask().execute() ，它将完全按照我的行为想要，我试试看。 @CommonsWare，您认为必须通过（单独的）HTTP 请求下载许多小文件是使用 ThreadPool 有意义的情况吗？ @treesAreEverywhere：嗯，使用后台线程对于网络 I/O 来说是必不可少的。是使用AsyncTask THREAD_POOL_EXECUTOR 还是制作自己的 Executor 取决于您。【参考方案4】：
我创建了一个抽象帮助类来确定内部版本号并适当地选择执行或 executeOnExecutor。看起来效果不错
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);
抽象类示例的实现：
public class MyTask extends MyAsyncTask<String, Void, Void>
@Override
protected Void doInBackground(String... params)
//do work
return null;
创建类的实例
new MyTask().executeContent("go");
【讨论】：
【参考方案5】：在兼容性库中存在一个 AsyncTaskCompat。该类包含一个静态方法 executeInParallel。
此方法等同于方法executeOrExecutor，您可以将此方法与API 4一起使用
查看使用示例：
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);
);
享受
【讨论】：
当您不能简单地更改项目中的 targetSDKVersion（在我的情况下为 10）时，这是一个完美的解决方案。谢谢。AsyncTaskCompat 已在 API 27 中删除以上是关于API 级别 11 之前的 AsyncTask.executeOnExecutor()的主要内容，如果未能解决你的问题，请参考以下文章
Android API 级别 30 setSystemBarsAppearance 不会覆盖主题数据