Android AsyncTask的工作原理

1 AsyncTask的基本使用

public abstract class AsyncTask<Params, Progress, Result> 

• Params：启动任务执行的输入参数，如http请求的url

• Progress：后台任务执行的百分比

• Result：后台执行任务最终返回的结果类型

对应参数不处理设置成Void

public class DownLoadAsyncTask extends AsyncTask<String,Integer,Bitmap> {

    /**
     * onPreExecute是可以选择性覆写的方法
     * 在主线程中执行,在异步任务执行之前,该方法将会被调用
     * 一般用来在执行后台任务前对UI做一些标记和准备工作，
     * 如在界面上显示一个进度条。
     */
    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }

    /**
     * 抽象方法必须覆写,执行异步任务的方法
     * @param params
     * @return
     */
    @Override
    protected Bitmap doInBackground(String... params) {
        return null;
    }

    /**
     * onProgressUpdate是可以选择性覆写的方法
     * 在主线程中执行,当后台任务的执行进度发生改变时,
     * 当然我们必须在doInBackground方法中调用publishProgress()
     * 来设置进度变化的值
     * @param values
     */
    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
    }

    /**
     * onPostExecute是可以选择性覆写的方法
     * 在主线程中执行,在异步任务执行完成后,此方法会被调用
     * 一般用于更新UI或其他必须在主线程执行的操作,传递参数bitmap为
     * doInBackground方法中的返回值
     * @param bitmap
     */
    @Override
    protected void onPostExecute(Bitmap bitmap) {
        super.onPostExecute(bitmap);
    }

    /**
     * onCancelled是可以选择性覆写的方法
     * 在主线程中,当异步任务被取消时,该方法将被调用,
     * 要注意的是这个时onPostExecute将不会被执行
     */
    @Override
    protected void onCancelled() {
        super.onCancelled();
    }
}

启动AsyncTask：

new DownLoadAsyncTask().execute();

AsyncTask在具体的使用过程中也是有一些条件限制的，主要有如下几点：

• AsyncTask的类必须在主线程中加载，这就意味着第一次访问AsyncTask必须发生在主线程，当然这个过程在Android 4.1及以上版本中已经被系统自动完成。在Android 5.0的源码中，可以查看 ActivityThread 的 main 方法，它会调用AsyncTask的init方法，这就满足了AsyncTask的类必须在主线程中进行加载这个条件了

• AsyncTask的对象必须在主线程中创建

• execute()必须在UI线程调用

• 不要在程序中直接调用 onPreExecute()、onPostExecute()、doInBackground() 和 onProgressUpdate()

• 一个AsyncTask对象只能执行一次，即只能调用一次 execute()，否则会报运行时异常

• 在Android 1.6之前，AsyncTask是串行执行任务，Android 1.6的时候AsyncTask开始采用线程池处理并行任务，但是从Android 3.0开始，为了避免AsyncTask所带来的并发错误，AsyncTask又采用了一个线程来串行执行任务。尽管如此，在Android 3.0以及后续版本中，仍然可以通过AsyncTask的 executeOnExecutor() 来并行执行任务

3 AsyncTask工作原理

为了能够更清晰的理解AsyncTask的工作原理，在分析原理之前，有必要对AsyncTask的内部构造做一个简单的说明。

我们知道AsyncTask能在 doInBackground() 执行耗时操作，其中耗时操作会由内部的一个线程池 THREAD_POOL_EXECUTOR 处理， onProgressUpdate()、onPostExecute() 切回主线程更新UI，而切换回UI线程是通过Handler收发消息实现的。

从 execute() 开始分析，execute() 会调用 executeOnExecutor()：

public final AsyncTask<Params, Progress, Result> execute(Params... params) {
	// sDefaultExecutor是一个串行的线程池
	// 一个进程中所有的AsyncTask全部在这个串行的线程池中排队执行
	return executeOnExecutor(sDefaultExecutor, params);
}

public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec, Params... params) {
	if (mStatus != Status.PENDING) {
		switch (mStatus) {
			case RUNNING:
			case FINISHED:
				// 抛异常
				break;
		}
	}
	mStatus = Status.RUNNING;
	onPreExecute(); // 在执行耗时操作前就回调onPreExecute()
	mWorker.mParams = params; // WorkerRunnable的call()方法会在线程池中执行回调doInBackground()
	exec.execute(mFuture); // FutureTask，在构造中会传入在线程池执行耗时任务的mWorker
	return this;
}

接下来分析线程池的执行过程：

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

// SerialExecutor线程池用于任务的排队，实际执行的线程池是THREAD_POOL_EXECUTOR
private static class SerialExecutor implements Executor {
	final ArrayDeque<Runnable> mTasks = new ArrayDeque<>();
	Runnable mActive;

	// 在AsyncTask.executorOnExecutor()中的sDefaultExecutor.execute()调用该方法
	// 传入的是AsyncTask的Params参数封装的FuterTask对象，是一个并发类充当Runnable
	public synchronized void execute(final Runnable r) {
		// 将Runnable存到队列中
		mTasks.offer(new Runnable() {
			public void run() {
				try {
					// 从这里可以看出在一个AsyncTask任务执行完后才去拿下一个AsyncTask任务
					// 调用FuterTask的run()，实际是调用的内部WorkerRunnable的call()
					r.run();
				} finally {
					scheduleNext(); // 执行下一个AsyncTask任务
				}
			}
		});
		if (mActive == null) {
			scheduleNext();
		}
	}

	protected synchronized void scheduleNext() {
		// 从队列中拿一个AsyncTaskr任务扔给线程池执行
		if ((mActive == mTasks.poll()) != null) {
			// 实际的耗时操作是在线程池THREAD_POOL_EXECUTOR执行
			THREAD_POOL_EXECUTOR.execute(mActive); 
		}
	}
}

FutureTask 的 run() 会调用 mWorker 的 call() 方法，因此 mWorker 的 call() 最终会在线程池中执行，在AsyncTask构造方法中：

mWorker = new WorkerRunnable<Params, Result>() {
	public Result call() throws Exception {
		mTaskInvoked.set(true); // 设置标志表示当前任务已经被调用了

		Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
		return postResult(doInBackground(mParams));
	}
};

mFuter = new FuterTask<Result>(mWorker) {...}

private Result postResult(Result result) {
	Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT, 
		new AsyncTaskResult<Result>(this, result));
	message.sendToTarget(); // 将doInBackground()的执行结果通过Handler发送切换回主线程更新UI
	return result;
}

private static final InternalHandler sHandler = new InternalHandler();

// 在线程池中获取的数据通过Handler从子线程切换回主线程更新UI
// InternalHandler是静态成员在加载类的时候会初始化，因此这就要求AsyncTask必须在主线程中加载
private static class InternalHandler extends Handler {
	@Override
	public void handleMessage(Message msg) {
		AsyncTaskResult result = (AsyncTaskResult) msg.obj;
		switch (msg.what) {
			case MESSAGE_POST_RESULT:
				result.mTask.finish(result.mData[0]); // 回调AsyncTask的finish
				break;
			case MESSAGE_POST_PROGRESS:
				result.mTask.onProgressUpdate(result.mData);
				break;	
		}
	}
}

private void finish(Result result) {
	if (isCancelled()) {
		onCancelled(result);
	} else {
		onPostExecute(result); // 回调结果
	}
	mStatus = Status.FINISHED;
}

// FutureTask内部
public FutureTask(Runnable runnable) {
	this.callable = callable;
	this.state = NEW;
}

public void run() {
	try {
		Callable<V> c = callable;
		if (c != null && state == NEW) {
			V result;
			try {
				result = c.call(); // 调用的是WorkerRunnable的call()
			} catch (Throwable ex) {...}
		}
	} finally {...}
}