Android AsyncTask源码分析

简介

Android中只能在主线程中进行UI操做，若是是其它子线程，须要借助异步消息处理机制Handler。除此以外，还有个很是方便的AsyncTask类，这个类内部封装了Handler和线程池。本文先简要介绍AsyncTask的用法，而后分析具体实现。

基本用法

AsyncTask是一个抽象类，咱们须要建立子类去继承它，而且重写一些方法。AsyncTask接受三个泛型参数：

• Params: 指定传给任务执行时的参数的类型
• Progress: 指定后台任务执行时将任务进度返回给UI线程的参数类型
• Result: 指定任务完成后返回的结果的类型

除了指定泛型参数，还须要根据须要重写一些方法，经常使用的以下:

• onPreExecute(): 这个方法在UI线程调用，用于在任务执行前作一些初始化操做，如在界面上显示加载进度控件
• doInBackground: 在onPreExecute()结束以后马上在后台线程调用，用于耗时操做。在这个方法中可调用publishProgress方法返回任务的执行进度
• onProgressUpdate: 在doInBackground调用publishProgress后被调用，工做在UI线程
• onPostExecute: 后台任务结束后被调用，工做在UI线程

源码分析

下面分析这个类的实现，主要有线程池以及Handler两部分。

线程池

当执行一个AsyncTask的时候调用的是execute()方法，就从这个开始看：

public final AsyncTask<Params, Progress, Result> execute(Params... params){
    return executeOnExecutor(sDefaultExecutor, params);
}
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
    onPreExecute();  
  
    mWorker.mParams = params;  
  
    exec.execute(mFuture);  
    return this; 
}

execute方法会调用executeOnExecutor。在这个方法中先检查任务是否已经执行或者执行结束，而后把任务标记为running。最开始执行的是onPreExecute，接着把参数赋值给mWorker对象。这个mWorker是一个Callable对象，最终被包装为FutureTask，代码以下：

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

mWorker = new WorkerRunnable<Params, Result>() {  
        public Result call() throws Exception {  
            mTaskInvoked.set(true);  

            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
            //noinspection unchecked  
            return postResult(doInBackground(mParams));  
        }  
    };
    
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 occured while executing doInBackground()",  
                    e.getCause());  
        } catch (CancellationException e) {  
            postResultIfNotInvoked(null);  
        }  
    }  
};

从上面的代码能够看出，在mWorker对象中的call()方法会调用doInbackground，返回值交给postResult方法，这个方法经过Handler发送消息，这一点稍后再详细分析。

在mWorker对象被封装成FutureTask以后交由线程池执行，从execute方法能够看出，使用的是sDefaultExecutor，它的值默认为SERIAL_EXECUTOR，也就是串行执行器，实现以下：

private static class SerialExecutor implements Executor {  
    //线性双向队列，用来存储全部的AsyncTask任务  
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();  
    //当前正在执行的AsyncTask任务  
    Runnable mActive;  

    public synchronized void execute(final Runnable r) {  
        //将新的AsyncTask任务加入到双向队列中  
        mTasks.offer(new Runnable() {  
            public void run() {  
                try {  
                    //执行AsyncTask任务  
                    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 THREAD_POOL_EXECUTOR  
        = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,  
                TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

在上面的代码中，若是有任务执行，那么SerialExecutor的execute方法会被调用，它的逻辑是把Runnable对象加入ArrayDeque队列中，而后判断mActivie是否为空。第一次执行时mActive固然为空，因此执行scheduleNext，其实就是取出任务队列中的第一个任务交给线程池(THREAD_POOL_EXECUTOR)执行。加入mTask队列的Runnable对象的run方法里最终必定会调用scheduleNext，那么又会从任务队列中取出队头任务执行。这样便实现了单线程顺序执行任务，因此在AsyncTask中默认启用的是单线程执行，只有上一个任务执行后才会执行下一个任务。若是想要启用多线程执行任务，能够直接调用 executeOnExecutor(Executor exec, Params... params)，这里的Executor参数可使用AsyncTask自带的THREAD_POOL_EXECUTOR，也能够本身定义。

Handler

AsyncTask内部用Handler传递消息，它的实现以下：

private static class InternalHandler extends Handler {  
    @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;  
        }  
    }  
}

若是消息类型是任务执行后的返回值(MESSAGE_POST_RESULT)将调用finish()方法：

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

从上面能够知道，若是任务取消了，将调用onCancelled，不然调用onPostExecute，因此一个AsyncTask任务若是取消了，那么onPostExecute将不会获得执行。

若是消息类型是执行进度(MESSAGE_POST_PROGRESS)将调用onProgressUpdate，这个方法默认是空方法，咱们能够根据本身的须要重写。

总结

AsyncTask的主要逻辑就如上面所分析的，总结几个须要注意的地方：

• AsyncTask的类必须在UI线程加载（从4.1开始系统会帮咱们自动完成）
• AsyncTask对象必须在UI线程建立
• execute方法必须在UI线程调用
• 不要手动调用onPreExecute()、doInBackground、onProgressUpdate方法
• 一个任务只能被调用一次（第二次调用会抛出异常）
• 多个 AsyncTask 默认是串行执行，能够改成并发执行，但要注意资源同步的问题。
• 大量 AsyncTask 任务填满线程池的队列会抛出异常。

其它还有一些细节能够自行研究源码，另外推荐几篇不错的文章：

1. Android源码分析—带你认识不同的AsyncTask
2. Android AsyncTask彻底解析，带你从源码的角度完全理解