AsyncTask 源码分析

AsyncTask 内部实现原理主要是两个线程池和一个handler。

两个线程池分别为SerialExecutor和ThreadPoolExecutor。

其中SerialExecutor是维护一个有序队列；ThreadPoolExecutor是执行任务的线程池。

handler是InternalHandler 执行异步操作的。

1.首先我们先来看下AsyncTask 的构造方法。

   public AsyncTask(@Nullable Looper callbackLooper) {
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);

        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
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    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);
                }
            }
        };
    }

从构造方法中我们可以看出 初始化了一个handler，以及初始化WorkerRunnable并实现了call()方法，还有初始化FutureTask并实现done()方法。

我们接着往下看

WorkerRunnable实际是一个Callable

private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

FutureTask是Runnable和Future的子类

public class FutureTask<V> implements RunnableFuture<V> 
public interface RunnableFuture<V> extends Runnable, Future<V> 

构造方法介绍完毕我们看下execute();的执行方法

 @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) {
		 // 1. 判断 AsyncTask 当前的执行状态
        // PENDING = 初始化状态
        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)");
            }
        }
 		// 将AsyncTask状态设置为RUNNING状态
        mStatus = Status.RUNNING;
		//  主线程初始化工作
        onPreExecute();
		// 添加参数到任务中
        mWorker.mParams = params;
        //  执行任务
        // 此处的exec = sDefaultExecutor = 任务队列 线程池类（SerialExecutor）的对象
       
        exec.execute(mFuture);

        return this;
    }

可以看到实际上是sDefaultExecutor执行了execute方法，那我们看下sDefaultExecutor实际是一个SerialExecutor线程池的对象

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

 public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

那么我们看下SerialExecutor

private static class SerialExecutor implements Executor {
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;


		// execute（）被同步锁synchronized修饰
        // 即说明：通过锁使得该队列保证AsyncTask中的任务是串行执行的
        // 即 多个任务需1个个加到该队列中；然后 执行完队列头部的再执行下一个，以此类推
        public synchronized void execute(final Runnable r) {
         	// 将实例化后的FutureTask类 的实例对象传入
            // 即相当于：向队列中加入一个新的任务
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            // 若当前无任务执行，则去队列中取出1个执行
            if (mActive == null) {
                scheduleNext();
            }
        }
		
        protected synchronized void scheduleNext() {
          	// 取出队列头部任务
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

这里面的Runnable其实就是我们传入的FutureTask对象
这里首先是先将一个个新任务加入队列然后scheduleNext方法从队列的头部取出任务一个个的执行。

执行任务的时候调用了FutureTask的run方法实际上就调用了mWorker的call()方法

public class FutureTask<V> implements RunnableFuture<V> 

public void run() {
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

这里的call对象实际就是在构造方法中传入的mWorker对象。

接着我们看下call()的实现方法就在构造方法中

  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
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);
                }
                return result;
            }
        };

可以看到这里执行了doInBackground 耗时任务 执行完把结果发给postResult
doInBackground 就是我们需要执行异步任务的地方
这里给出了调用的demo

  AsyncTask asyncTask = new AsyncTask() {
            @Override
            protected Object doInBackground(Object[] params) {
                getDatas();
                return null;
            }

            @Override
            protected void onPostExecute(Object o) {
                
            }
        };
        asyncTask.execute();

分析postResult(result)

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

这里的getHandler实际就是InternalHandler
postResult方法给InternalHandler 发送了一个message MESSAGE_POST_RESULT和一个 AsyncTaskResult

private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);
        }

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

result.mTask实际就是AsyncTask自己

private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

        AsyncTaskResult(AsyncTask task, Data... data) {
            mTask = task;
            mData = data;
        }
    }

InternalHandler 接受到MESSAGE_POST_RESULT执行AsyncTask的finish方法

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

这里就执行了我们实现的onCancelled或onPostExecute

总结

1.任务线程池类（THREAD_POOL_EXECUTOR）实际上是1个已配置好的可执行并行任务的线程池
2.调用THREAD_POOL_EXECUTOR.execute（）实际上是调用线程池的execute()去执行具体耗时任务
3.而该耗时任务则是步骤2中初始化 WorkerRunnable实例对象时复写的call（）内容
4.在call（）方法里，先调用 我们复写的doInBackground(mParams)执行耗时操作
5.再调用postResult(result)， 通过 InternalHandler 类 将任务消息传递到主线程；根据消息标识（MESSAGE_POST_RESULT）判断，最终通过finish(）调用我们复写的onPostExecute(result)，从而实现UI更新操作