-----基于Android6.0分析
AsyncTask是一个抽象类,我们去使用它的时候需要创建一个子类继承它。
它是Android为我们封装的处理耗时操作的类
AsyncTask也是使用的异步消息处理机制，只是做了非常好的封装而已。
framework/base/core/java/android/os/AsyncTask.java
public abstract class AsyncTask<Params, Progress, Result>
AsyncTask的参数由三个泛型设定，所以当我们创建子类的时候必须为其制定泛型的类型，下面由一个例子来说明，这三个泛型会影响AsyncTask类中的哪几个函数的参数和返回值
import android.os.AsyncTask;
public class DownLoadTask extends AsyncTask<String, Void, Boolean>{
@Override
protected Boolean doInBackground(String... params) {
// TODO Auto-generated method stub
return null;
}
@Override
protected void onPostExecute(Boolean result) {
// TODO Auto-generated method stub
super.onPostExecute(result);
}
@Override
protected void onProgressUpdate(Void... values) {
// TODO Auto-generated method stub
super.onProgressUpdate(values);
}
}
Params：doInBackground的参数类型
Progress：onProgressUpdate的参数类型
Result：doInBackground的返回类型和onPostExecute参数类型
我们首先来看下AsyncTask的构造函数，初始化两个参数mWorker 和mFuture，mWorker是一个Callable对象，mFuture是一个FutureTask对象
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);
}
}
};
}
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
FutureTask 这个类在我们电脑上配置的JAVA环境中的 rt.jar 中
// packname:java.util.concurrent
public FutureTask(Callable<V> paramCallable)
{
if (paramCallable == null)
throw new NullPointerException();
this.callable = paramCallable;
this.state = 0;
}
把mWorker 保存在FutureTask 的callable 变量中。到这里，AsyncTask的初始化工作已经完成。下面就是Task的启动execute方法
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
// private static volatile Executor sDefaultExecutor = new SerialExecutor();
接着看 executeOnExecutor 方法
@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;
}
函数中 首先会执行onPreExecute(),可是doInBackground()是哪调用的呢，不用着急，我们慢慢找找，唯一可疑的就是exec.execute(mFuture);这个方法，我们点进去看看。因为exec就是刚才传进去的sDefaultExecutor，而sDefaultExecutor又是SerialExecutor对象，所以这里调用的就是SerialExecutor的execute方法。
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);
}
}
}
仔细观察上面的代码，设计的很有意思，
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
SerialExecutor在AsyncTask以常量的形式被使用，因此整个应用程序中的所有AsyncTask实例都会共用同一个SerialExecutor。SerialExecutor采用ArrayDeque这个队列来维护添加进的线程任务Runable.当我们一次性执行很多任务时，第一次运行会mActive 肯定等于null了，所以就调用scheduleNext函数，
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;
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
允许在同一时刻有CORE_POOL_SIZE个任务正在执行，并且最多能够存储MAXIMUM_POOL_SIZE个任务。
他会取出ArrayDeque的队首的Runable给mActive ，然后执行 THREAD_POOL_EXECUTOR.execute(mActive);去启动Runable的Run函数，之后又有新的任务被offer到队列中，这次mActive已然不等null，因为她保存了第一次的添加进来的Runable对象。但是呢，在run函数中有这么一段代码
try {
r.run();
} finally {
scheduleNext();
}
每次执行完Runable的任务后，都会去执行scheduleNext()函数，这就保证同一时刻只会有一个线程正在执行，其余的均处于等待状态，是不是有点像单一线程池的效果。接下来，可以知道execute开辟了一个线程Runnable 去执行mFuture的run函数
public void run()
{
.......
try
{
Callable localCallable = this.callable;
if ((localCallable != null) && (this.state == 0))
{
Object localObject1;
int j;
try
{
localObject1 = localCallable.call();
j = 1;
}
catch (Throwable localThrowable)
{
......
}
if (j != 0)
set(localObject1);
}
}
......
}
this.callable就是AsyncTask初始化创建的mWorker即WorkerRunnable对象，这里主要是调用了其call()函数，再来看看WorkerRunnable的call函数到底做了哪些工作
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);
}
};
这是AsyncTask构造函数中的一段代码，发现了没有，里面执行了doInBackground函数。到现在 我们把思路捋一下。
1、初始化AsyncTask的时候会创建mWorker和mFuture对象，在mFuture中会把mWorker当做参数传给mFuture的callable成员变量
2、执行exec的时候会调用executeOnExecutor，然后在executeOnExecutor里面调用onPreExecute，exec.execute(mFuture);
3、SerialExecutor是AsyncTask的内部静态类。exec.execute(mFuture)会调用SerialExecutor的execute函数，在这里面会开辟线程去执行mFuture.run(),紧接着run函数调用mWorker的call函数，进而执行doInBackground，经过这几步，不难doInBackground执行在子县城中，这就是为什么doInBackground可以执行耗时操作的原因。
紧接着我们看postResult的源码
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
熟悉android Handler机制的同学应该会知道，这条消息最终会被getHandler()得到的Handler对象中handleMessage去处理
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}
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中的消息有两个类型
1.MESSAGE_POST_RESULT
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
如果task没有取消就调用onPostExecute，取消的话就执行onCancelled
2.MESSAGE_POST_PROGRESS
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
这也说明在doInBackground中调用publishProgress可以总子线程切换到UI线程从而进行UI线程的控件更新。
好了，AsyncTask的原理到这里就介绍完了。
