android多线程之AsyncTask源码分析

在有关线程的操作中一定要记住两点：

1、不能在UI线程中执行耗时的操作

2、不能在非主线程中更新UI界面

---

一、AsyncTask简介

AsyncTask封装了线程池和Handler，是Android的一个轻量级的异步类，它可以在线程池中执行后台操作，然后把执行的进度和结果通过Handler传递给主线程并在主线程里面更新UI。可以方便开发者实现异步操作。

---

二、AsyncTask用法和示例

1、用法

AsyncTask是一个抽象的泛型类，提供了Params、Progress、Result三个泛型参数

public abstract class AsyncTask(){}

Params:需要传入参数的类型
Progress：后台任务的执行进度的类型
Result：后台任务返回结果的类型

AsyncTask提供了4个核心的方法，分别是：

1. OnPreExecute(), 在主线程中执行，在异步任务之前，此方法被调用一般做一些准备性的工作；

2. doInBackground(Params...params),在线程池中执行，用于执行异步任务，params表示异步任务的传入参数，此方法会调用publshProgress()来更新任务进度，publshProgress()会调用onProgressupdate()，会返回计算结果给onPostExecute().

3. onProgressUpdate(Progress...value)，在主线程中执行，后台执行任务的进度有变化时被调用。

4. onPostExecute(Result result), 在主线程中执行，在异步任务执行之后，此方法会被调用，result为后台任务的返回值，即doInBackground()的返回值。

2、示例

public class DownloadFilesTask extends AsyncTask{
    protected Long doInBackground(URL...url){
        int count = url.length;
        long totalSize = 0;
        for(int i = 0; i< count; i++){
            totalSize += DownloadFile(url[i]);
            publishProgress((int) (i/(float)count)*1000);
            if(isCancelled){
                break;
            }
        }
    }
    
    protected void onProgressUpdate(Integer...progress){
        setProgressPercent(progress[0]);
    }

    protected void onPostExecute(Long result){
        showDialog("bytes"+result);
    }
}

在DownloadFileTask中，doInBackground()执行下载任务并通过publishProgress()来更新进度，同时还会调用isCancelled()判断下载任务是否被取消。下载任务完成后doInBackground()会返回结果。publishProgress()被执行了调用onProgressUpdate()方法更新进度。当下载任务完成后onPostExecute()就会被调用，在主线程中做一些改变。

---

三、AsyncTask的限制

1. AsyncTask的类必须在主线程里加载；

2. AsyncTask的对象必须在主线程中调用；

3. execute方法必须在UI线程调用；

4. 不要在程序中直接调用onPreExecute()、onPostExecute()、doInBackground()、和onProgressUpdate()；

5. 一个AsyncTask对象只能执行一次，即只能调用一次execute(),否则会报运行时异常；

三、AsyncTask工作原理

列表内容分析AsyncTask原理，先从execute()开始，execute()调用了executor(),源码实现如下：

public final AsyncTask execute(Params...params){
    return executeOnExecutor(sDefaultExecutor params);
}

public final AsyncTask executeOnExecutor(Executorexec, 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 is already finishing.")
        }
    }
    mStatus = Status.RUNNING;
    onPreExecute();
    mWorker.mParams = params;
    exec.execute(mFuture);
    return this;
}

sDefaultExecutor实际上是一个串行的线程池，一个进程的所有的线程都在这个串行的线程池里面排队，在executor()方法中， AsyncTask的onProExecute() 最先执行，然后线程池开始执行。

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

private static volatile Executor sDefaultExecutor = SERIAL＿EXECUTOR;

private static class SerialExecutor implements Executor {
    final ArrayDeque mTasks = new ArrayDeque();
    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);
        }
    }
}

系统把AsyncTask的Params参数封装为FutureTask对象，Future是一个并发类，充当Runnable的作用，接着这个FutureTask会交给SerialExecutor的execute方法去处理，SerialExecutor的execute方法会把FutureTask插入到mTask任务队列中，如果没有正在执行的任务，那么就会调用SerialExecutor的scheduleNext方法来执行下一个AsyncTask任务，同时当一个任务执行完后，AsyncTask会继续调用其他任务直到所有任务都被执行完。

AsyncTask有两个线程池，SerialExecutor 和THREAD_POOL_EXECUTOR和一个Handler(InternalHandler)，SerialExecutor用于任务的排队，而THREAD_POOL_EXECUTOR用于真正的执行任务，而InternalHandler用于将执行环境从线程池切换到主线程。

mWorker = new WorkerRunnable(){
    public Result call() throws Exception{
        mTaskInvoked.set(true);
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        return postResult(donInBackground(mParams));
    }
};

在mWorker的call方法中将mTaskInvoked设为true，表示当前任务已经被调用了，然后执行doInBackground方法，接着返回值传递给postResult方法。

private Result postResult (Result result){
    Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult(this, result));
    message.sendToTarget();
    return result;
}

postResult方法会通过sHandler发送一个MESSAGE_POST_RESULT的消息，这个sHandler的定义如下：

private static final InternalHandler sHandler = new InternalHandler();

private static class InternalHandler extends Handler{
    public void handleMessage(Message msg){
        AsyncTaskResult result = (AsyncTaskResult)msg.obj;
        switch(msg.what){
            case MESSAGE_POST_RESULT:
                result.mTask.finish(result.mData[0]);
                break;
            case MESSAGE_POST_PROGRESS:
                result.mTask.onProgressUpdate(result.mData);
                break;
        }
    }
}

sHandler是一个静态的Handler对象，为了能够将执行环境切换到主线程，这就要求sHandler必须是在主线程中创建。由于静态成员在加载类的时候进行初始化，这就要求AsyncTask的类必须在主线程中加载。sHandler收到MESSAGE_POST_RESULT这个消息后会调用AsyncTask的finish方法。

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

如果AsyncTask被取消执行了，那么就会调用onCanedlled方法，否则就会调用onPostExecute方法，doInBackground的返回结果传递给onPostExecute方法。到这里AsyncTask的整个工作过程就分析完毕了。