android学习日志—AsyncTask源码分析

1.概述

AsyncTask是Android自带的一个异步任务类，在面试过程中，也经常涉及到。面试官可能会问：你是怎么看待Android异步任务的？AsyncTask为什么只能执行一次？想要真正了解AsyncTask，还得去看看它的内部实现。

2.源码分析

AsyncTask是一个抽象类，我们需要继承它，实现其内部的部分方法，如下：

class MyAsyncTask extends AsyncTask<Params, Progress, Result>{
@Override
protected Result doInBackground(Params...params)｛
//耗时操作，属于子线程
...
｝
@Override
protected void onPostExecute(String result) {
//获取结果，进行UI操作，属于主线程
super.onPostExecute(result);
}
@Override
protected void onProgressUpdate(Integer... values) {
//更新操作进度，属于主线程
super.onProgressUpdate(values);
}
}

首先，我们在使用的时候当然也是先实例化：MyAsyncTask task=new MyAsyncTask();当我们写这段代码的时候，AsyncTask执行了哪些操作，让我们看一下源码：

public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority
(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(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);
}
}
};
}

AsyncTask的构造方法中，实例化了两个变量：WorkerRunnable和FutureTask。

WorkerRunnable

WorkerRunnable类实现了callable接口的call()方法，可以有返回值。

第8行执行了doInBackground方法，执行耗时操作，并获得返回值result。

第10行返回result并调用postResult方法，将执行结果发送给主线程。代码如下：

private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message=getHandler().obtainMessage
(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}

通过Handler将消息(msg.what=MESSAGE_POST_RESULT,msg.obj=new AsyncTaskResult(this, result))发送到主线程。获取Handler方法如下：

private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}

获取一个单例的Handler。这里的InternalHandler就是继承Handler实现的：

private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper());
}
@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;
}
}
}

实现了handleMessage方法根据msg.what，区别不同的消息。

上面postResult方法发送来的消息msg.what=MESSAGE_POST_RESULT，

执行result.mTask的finish方法，如下：

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

判断任务是否取消，是则执行onCancelled方法，否则执行onPostExecute方法获取执行结果。

如果消息msg.what=MESSAGE_POST_PROGRESS则执行result.mTask的onProgressUpdate方法，更新操作进度，下面将会讲到。

FutureTask

FutureTask实现了Future和Runnable接口，是一种可以取消的异步任务，可以通过Excutor(线程池) 来执行，这里实现了done方法。

其中有一个构造方法：

public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW;    // ensure visibility of callable
}

这里将WorkRunnable传入FutureTask。

其次，实例化完AsyncTask对象task后，我们会调用task.execute(Params…params)，代码如下：

@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}

也就是调用下面的方法：

@MainThread
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;
}

第4行首先判断AsyncTask的状态，如果不是未执行(PENDING)状态，则又可分为正在运行(RUNNING)状态和完成(FINISHED)状态。正在运行状态下会抛出”Cannot execute task:the task is already running”异常；完成状态会抛出”Cannot execute task: the task has already been executed “异常，这也就是为什么一个AsyncTask只能execute一次，正常执行后状态会置为Status.RUNNING(即第15行代码)，执行完毕后状态会置为Status.FINISHED。状态的改变导致AsyncTask只能执行一次。

第17行回调onPreExecute()，可以定义执行前的一些操作。

第18行将参数params传给WorkRunnable。

第19行通过调用Executor的execute方法执行FutureTask(下面会讲到)。这里的Executor是上面传入的sDefaultExecutor，看一下这个变量在AsyncTask是怎么定义的：

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

它是一个叫SerialExecutor的类的实例，此类实现Executor接口，定义如下：

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);
}
}
}

第2行定义了一个ArrayDeque，这是一个双向队列，其offer方法是指定的元素放在此deque队列的末尾。

第3行定义一个记录当前活跃状态的任务。

第5行开始线程池执行方法，依次将任务放到ArrayDeque的末尾，任务的run方法执行传入的Runnable接口的run方法，实际上这里的Runnable就是上面传入的FutureTask。一个任务执行完毕后会调用scheduleNext()方法通过ArrayDeque的poll()方法，取出队列头部的任务，依次执行。

第22行将任务交给另一个线程池THREAD_POOL_EXECUTOR执行。下面是定义：

private static final int CPU_COUNT =                   Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
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>(128);

/**
* 一个可以并行执行的线程池
*/
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

第19-21行可知，这个线程池的核心线程数为CPU核心数＋1个，最大线程数CPU核心数＊2+1个，空闲线程结束的超时时间为1秒钟，存放任务的队列为BlockingQueue(其中任务数量为128个)。

结语

一个小小的AsyncTask就牵扯出了这么多知识点，所以看源码还是很有必要的。