定义
AsyncTask是一个抽象类，在使用时需要继承该类，实现其抽象方法protected abstract Result doInBackground(Params... params)。其主要作用就是实现多线程以及异步通信。其实现也是用Thread+Handler来进行实现的。
AsyncTask类的定义:
public abstract class AsyncTask<Params, Progress, Result> {
}
三个泛型参数解释：
- Params：开始异步任务执行时传入的参数类型，对应excute()中传递的参数
- Progress：异步任务执行过程中，返回下载进度值的类型
- Result：异步任务执行完成后，返回的结果类型，与doInBackground()的返回值类型保持一致
核心方法
// 作用：执行 线程任务前的操作
@Override
protected void onPreExecute() {
// 根据需求复写
}
// 作用：接收输入参数,执行任务中的耗时操作,返回线程任务执行的结果
// 注：必须复写，从而自定义线程任务
@Override
protected Result doInBackground(Params... params) {
...// 自定义的线程任务
// 可调用publishProgress()显示进度, 之后将执行onProgressUpdate()
// 通过Handler发送消息进行更新进度
publishProgress(count);
}
// 作用：在主线程显示线程任务执行的进度
@Override
protected void onProgressUpdate(Progress... values) {
// 注：根据需求复写
}
// 作用：接收线程任务执行结果,将执行结果显示到UI组件
@Override
protected void onPostExecute(Result result) {
...// UI操作
}
// 作用：将异步任务设置为：取消状态
@Override
protected void onCancelled() {
...
}
只有doInBackground()运行在子线程中，其余都运行在主线程中。在onPreExecute()执行完后，会立即执行doInBackground()方法。
使用方法
创建类继承AsyncTask类，传入相应的泛型参数，实现doInBackground()方法。然后再创建该类的对象，使用对象.execute()进行执行。
public class MyAsyncTask extends AsyncTask<String, Integer, String> {
@Override
protected String doInBackground(String... params) {
return ...;
}
}
// 创建对象
MyAsyncTask myAsyncTask = new MyAsyncTask(String, Integer, String);
// 执行方法
myAsyncTask.execute(String);
源码分析
AsyncTask主要步骤就是创建该类对象，执行execute方法。所以可以主要就从这两条线去查看源码。
构造函数
public AsyncTask(@Nullable Looper callbackLooper) {
// 创建一个Handler，创建的时候如果没有传入Looper对象，则创建的就是主线程的Handler
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
// mWorker代表了AsyncTask要执行的任务，WorkerRunnable是对Callable接口的封装,而mWorker作为参数传递给了mFuture
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Result result = null;
try {
// 设置优先级
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
// doInBackground()就是我们需要覆写的方法
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);
throw tr;
} finally {
// 最终的结果通过该方法使用Handler发送消息出去
postResult(result);
}
return result;
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
} catch (InterruptedException e) {
android.util.Log.w(LOG_TAG, e);
} catch (ExecutionException e) {
throw new RuntimeException("An error occurred while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}
构造函数可以为空，则调用上述构造方法传入的Looper对象为空。也可以传入Handler对象，最终也是调用上述构造方法，传入该Handler的Looper对象。
构造方法中会调用我们覆写的doInBackground()方法，返回值通过postResult()方法进行消息发送。
private Result postResult(Result result) {
// getHandler()就是获取构造函数创建的Handler
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
execute方法
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
execute方法需要在主线程中调用，返回调用executeOnExecutor()方法的返回值。
@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
... 省略部分源码
mStatus = Status.RUNNING;
// 该方法就是执行doInBackground()方法之前的所执行的方法，可以根据需求进行覆写。
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
可以看到executeOnExecutor()传入了一个sDefaultExecutor的参数。
// sDefaultExecutor是一个静态常量
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
// SERIAL_EXECUTOR 是一个Executor的实现类对象
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static class SerialExecutor implements Executor {
// 定义了一个双端队列
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
public synchronized void execute(final Runnable r) {
// 通过offer方法从队列尾部插入
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);
}
}
}
每次调用execute，就创建一个Runnable匿名内部类对象，这个对象存入双端队列mTasks，在匿名内部类的run函数里面调用传入参数r.run()。然后通过一个scheduleNext函数把mTasks里面的所有对象通过THREAD_POOL_EXECUTOR.execute(mActive)执行一遍。SerialExecutor类会把所有的任务丢入一个容器，之后把容器里面的所有对象一个一个的排队（串行化）执行THREAD_POOL_EXECUTOR.execute(mActive);
// THREAD_POOL_EXECUTOR 也是一个静态常量，也就是一个ThreadPoolExecutor线程池对象
public static final Executor THREAD_POOL_EXECUTOR;
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
最终也就是通过线程池执行所有的线程任务。
总结
线程池的创建:
在创建了AsyncTask的时候，会默认创建两个线程池SerialExecutor和ThreadPoolExecutor，SerialExecutor负责将任务串行化，ThreadPoolExecutor是真正执行任务的地方，且无论有多少个AsyncTask实例，两个线程池都会只有一份。任务的执行:
在execute中，会执行run方法，当执行完run方法后，会调用scheduleNext()不断的从双端队列中轮询，获取下一个任务并继续放到一个子线程中执行，直到异步任务执行完毕消息的处理：
在执行完onPreExecute()方法之后，执行了doInBackground()方法，然后就不断的发送请求获取数据；在这个AsyncTask中维护了一个Handler，获取的数据是通过handler进行处理和发送的。在其handleMessage方法中，将消息传递给onProgressUpdate()进行进度的更新，也就可以将结果发送到主线程中，进行界面的更新了。使用AsyncTask的注意点
每一个new出的AsyncTask只能执行一次execute()方法，多次运行将会报错，如需多次，需要新new一个AsyncTask。
优缺点
优点：AsyncTask是一个轻量级的异步任务处理类，轻量级体现在，使用方便、代码简洁上，而且整个异步任务的过程可以通过cancel()进行控制；
缺点：不适用于处理长时间的异步任务，一般这个异步任务的过程最好控制在几秒以内，如果是长时间的异步任务就需要考虑多线程的控制问题；当处理多个异步任务时，UI更新变得困难。
使用注意事项
- AsyncTask不与任何组件绑定生命周期，在Activity 或 Fragment中使用 AsyncTask时，最好在Activity 或 Fragment的onDestory（）调用 cancel(boolean)；
- 若AsyncTask被声明为Activity的非静态内部类，当Activity需销毁时，会因AsyncTask保留对Activity的引用 而导致Activity无法被回收，最终引起内存泄露，最好将AsyncTask声明为Activity的静态内部类
