Android AsyncTask 源码解析

AsyncTask 是Android 轻量级的异步框架,下面从源码角度分析下AsyncTask是如何实现的

其中涉及到的一些Java并发知识,先在这里列出,随后不断补充

AsyncTask的调度

在API3.0以后,AsyncTask是串行处理所有任务的,3.0之前是并行处理,从ActicityThread的注释中可以看出

// If the app is Honeycomb MR1 or earlier, switch its AsyncTask// implementation to use the pool executor.  Normally, we use the// serialized executor as the default. This has to happen in the// main thread so the main looper is set right.

AsyncTask的初始化

AsyncTask在类加载时,会初始化一下静态变量,这些静态变量起着至关重要的作用,我们看下都有些什么

工作线程池

    // 工作线程池需要的参数    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();    // We want at least 2 threads and at most 4 threads in the core pool,    // preferring to have 1 less than the CPU count to avoid saturating    // the CPU with background work    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;    private static final int KEEP_ALIVE_SECONDS = 30;    // 构造执行线程    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);    /**     * An {@link Executor} that can be used to execute tasks in parallel.     */    // 工作线程池    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;    }

工作线程池用来执行后台任务,在静态变量中进行初始化

串行线程池

串行线程池用来存放消息队列

/**     * An {@link Executor} that executes tasks one at a time in serial     * order.  This serialization is global to a particular process.     */    // 串行队列,用来存储任务    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) {            // 取出待执行任务            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);            }        }    }

最重要的是Handler , AsyncTask是非常依赖Handler,进行通信的

// 这是依赖于主线程的Handlerprivate static InternalHandler sHandler;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;        }    }}

onPreExecute()

后台任务执行前,进行回调,这是一个模板方法

@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;        // 构造AsyncTask对象时，将params 封装成mFuture        // 实际执行这个mFuture        exec.execute(mFuture);        return this;    }

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();                //将结果使用Handler post回主线程                return postResult(result);            }        };         // 构造AsyncTask对象时，将params 封装成mFuture        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);                }            }        };    }

doInBackground()

执行完成后，post回主线程

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();                //将结果使用Handler post回主线程                return postResult(result);            }        };

onPostExecute()

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

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