AsyncTask

public abstract class AsyncTask
extends Object

AsyncTask支持正确和简单地使用UI线程。 该类允许执行后台操作并在UI线程上发布结果，而无需操纵线程和/或处理程序。

AsyncTask被设计成一个围绕Thread和Handler的帮助类，并不构成通用的线程框架。 AsyncTasks应该理想地（最多几秒钟。）可用于短期操作。如果您需要保持对长时间运行的线程，强烈建议您使用所提供的各种API java.util.concurrent包装如Executor ， ThreadPoolExecutor和FutureTask 。

异步任务由在后台线程上运行的计算定义，并且其结果在UI线程上发布。 异步任务是由3种一般类型定义，称为Params ， Progress和Result ，和4个步骤，称为onPreExecute ， doInBackground ， onProgressUpdate和onPostExecute 。

Usage

AsyncTask必须被子类化才能使用。 子类将覆盖的至少一种方法（ doInBackground(Params...) ），最经常将覆盖的第二个（ onPostExecute(Result) ）。

这是一个子类化的例子：

 private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
     protected Long doInBackground(URL... urls) {
         int count = urls.length;
         long totalSize = 0;
         for (int i = 0; i < count; i++) {
             totalSize += Downloader.downloadFile(urls[i]);
             publishProgress((int) ((i / (float) count) * 100));
             // Escape early if cancel() is called
             if (isCancelled()) break;
         }
         return totalSize;
     }

     protected void onProgressUpdate(Integer... progress) {
         setProgressPercent(progress[0]);
     }

     protected void onPostExecute(Long result) {
         showDialog("Downloaded " + result + " bytes");
     }
 }
 

一旦创建完成，任务就非常简单地执行：

 new DownloadFilesTask().execute(url1, url2, url3);
 

AsyncTask's generic types

异步任务使用的三种类型如下：

1. Params, the type of the parameters sent to the task upon execution.
2. Progress, the type of the progress units published during the background computation.
3. Result, the type of the result of the background computation.

并非所有类型总是由异步任务使用。 要将某个类型标记为未使用，只需使用类型Void ：

 private class MyTask extends AsyncTask<Void, Void, Void> { ... }
 

The 4 steps

当执行一个异步任务时，任务需要经过4个步骤：

1. onPreExecute(), invoked on the UI thread before the task is executed. This step is normally used to setup the task, for instance by showing a progress bar in the user interface.
2. doInBackground(Params...), invoked on the background thread immediately after onPreExecute() finishes executing. This step is used to perform background computation that can take a long time. The parameters of the asynchronous task are passed to this step. The result of the computation must be returned by this step and will be passed back to the last step. This step can also use publishProgress(Progress...) to publish one or more units of progress. These values are published on the UI thread, in the onProgressUpdate(Progress...) step.
3. onProgressUpdate(Progress...), invoked on the UI thread after a call to publishProgress(Progress...). The timing of the execution is undefined. This method is used to display any form of progress in the user interface while the background computation is still executing. For instance, it can be used to animate a progress bar or show logs in a text field.
4. onPostExecute(Result), invoked on the UI thread after the background computation finishes. The result of the background computation is passed to this step as a parameter.

Cancelling a task

通过调用cancel(boolean)可以随时取消任务。 调用此方法将导致对isCancelled()后续调用返回true。 调用此方法后， onCancelled(Object) ，而不是onPostExecute(Object)后会被调用doInBackground(Object[])回报。 为了确保任务是尽快取消，您应经常检查返回值isCancelled()定期从doInBackground(Object[]) ，如果可能的话（例如一个循环中。）

Threading rules

有一些线程规则必须遵循才能正确工作：

• The AsyncTask class must be loaded on the UI thread. This is done automatically as of JELLY_BEAN.
• The task instance must be created on the UI thread.
• execute(Params...) must be invoked on the UI thread.
• Do not call onPreExecute(), onPostExecute(Result), doInBackground(Params...), onProgressUpdate(Progress...) manually.
• The task can be executed only once (an exception will be thrown if a second execution is attempted.)

Memory observability

AsyncTask保证所有的回调调用都是以这样一种方式进行同步的，即在没有明确同步的情况下以下操作是安全的。

• Set member fields in the constructor or onPreExecute(), and refer to them in doInBackground(Params...).
• Set member fields in doInBackground(Params...), and refer to them in onProgressUpdate(Progress...) and onPostExecute(Result).

Order of execution

首次引入时，AsyncTasks在单个后台线程上被串行执行。 从DONUT开始，这被更改为允许多个任务并行操作的线程池。 从HONEYCOMB开始，任务在单个线程上执行，以避免由并行执行导致的常见应用程序错误。

如果你真的想并行执行，你可以调用 executeOnExecutor(java.util.concurrent.Executor, Object[])与 THREAD_POOL_EXECUTOR 。

Summary

Inherited methods

From class java.lang.Object Object clone() 创建并返回此对象的副本。 boolean equals(Object obj) 指示其他某个对象是否“等于”这一个。 void finalize() 当垃圾收集确定没有更多对该对象的引用时，由对象上的垃圾回收器调用。 final Class<?> getClass() 返回此 Object的运行时类。 int hashCode() 返回对象的哈希码值。 final void notify() 唤醒正在等待该对象监视器的单个线程。 final void notifyAll() 唤醒在该对象监视器上等待的所有线程。 String toString() 返回对象的字符串表示形式。 final void wait(long millis, int nanos) 导致当前线程等待，直到另一个线程调用此对象的方法 notify()或 notifyAll()方法，或其他某个线程中断当前线程或经过一定的实时时间。 final void wait(long millis) 导致当前线程等待，直到另一个线程调用此对象的 notify()方法或 notifyAll()方法或经过了指定的时间量。 final void wait() 导致当前线程等待，直到另一个线程调用此对象的 notify()方法或 notifyAll()方法。

Fields

Executor SERIAL_EXECUTOR

Executor THREAD_POOL_EXECUTOR

Public constructors

AsyncTask ()

Public methods

boolean cancel (boolean mayInterruptIfRunning)

AsyncTask<Params, Progress, Result> execute (Params... params)

void execute (Runnable runnable)

AsyncTask<Params, Progress, Result> executeOnExecutor (Executor exec, 
                Params... params)

Result get (long timeout, 
                TimeUnit unit)

Result get ()

AsyncTask.Status getStatus ()

boolean isCancelled ()

Protected methods

Result doInBackground (Params... params)

void onCancelled ()

void onCancelled (Result result)

void onPostExecute (Result result)

void onPreExecute ()

void onProgressUpdate (Progress... values)

void publishProgress (Progress... values)