AsyncTask的源碼是很簡(jiǎn)單的彩倚，看著并不復(fù)雜筹我。只是對(duì)Handler和ThreadPoolExecutor進(jìn)行了一下封裝。

基于api25（7.1）的代碼署恍，

使用起來(lái)也是很簡(jiǎn)單的崎溃，看上個(gè)就知道了。一般要繼承AsyncTask并重寫下面幾個(gè)方法,這些方法的執(zhí)行順序一目了然：

原文地址 http://blog.csdn.net/qq_25806863/article/details/72820844

//任務(wù)執(zhí)行前調(diào)用
protected void onPreExecute() {}
//執(zhí)行后臺(tái)任務(wù)
protected abstract Result doInBackground(Params... params);
//返回任務(wù)執(zhí)行結(jié)果
protected void onPostExecute(Result result) {}
//返回任務(wù)執(zhí)行進(jìn)度
protected void onProgressUpdate(Progress... values) {}
//任務(wù)取消時(shí)調(diào)用
protected void onCancelled() {}

只有doInBackground一個(gè)方法是抽象的盯质，必須重寫袁串，其他的可以不用重寫。

然后通常的調(diào)用方法是這樣的：

new MyAsyncTask().execute();

Handler和線程池

既然是對(duì)Handler和線程池的封裝呼巷，就先看看封裝的什么用的Handler和線程池囱修。都是定義在AsyncTask類中。

handler

private static InternalHandler 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;
            }
        }
    }
private static Handler getHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler();
            }
            return sHandler;
        }
    }

首先有一個(gè)變量sHandler王悍。

InternalHandler是一個(gè)靜態(tài)內(nèi)部類

在這個(gè)構(gòu)造方法中可以看出破镰，InternalHandler使用了主線程也就是UI線程的Looper來(lái)處理消息，所以這個(gè)Handler收到的消息會(huì)在主線程中處理压储。使用這個(gè)Handler就達(dá)到了跟主線程進(jìn)行交互的目的鲜漩。

然后提供了一個(gè)方法getHandler，用單例來(lái)獲取唯一的一個(gè)InternalHandler集惋。

線程池

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

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//默認(rèn)的線程池
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

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);
            }
        }
    }
/** @hide */
    public static void setDefaultExecutor(Executor exec) {
        sDefaultExecutor = exec;
    }

在這里可以看見連個(gè)線程池孕似，THREAD_POOL_EXECUTOR和SERIAL_EXECUTOR,以及一個(gè)默認(rèn)使用的線程池變量sDefaultExecutor。

這兩個(gè)線程池關(guān)系到了為什么AsyncTask的任務(wù)是串行的刮刑。在ActivityThread中有這樣一段代碼：

//android.os.Build.VERSION_CODES.HONEYCOMB_MR1=12
if (data.appInfo.targetSdkVersion <= android.os.Build.VERSION_CODES.HONEYCOMB_MR1) {
    AsyncTask.setDefaultExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}

看來(lái)只有當(dāng)版本小于13的時(shí)候喉祭，才會(huì)將THREAD_POOL_EXECUTOR作為默認(rèn)線程池，可以并行執(zhí)行任務(wù)雷绢。

THREAD_POOL_EXECUTOR

其中THREAD_POOL_EXECUTOR是在靜態(tài)代碼塊中定義的泛烙，在類加載的時(shí)候就執(zhí)行了，而且只會(huì)執(zhí)行一次翘紊。

直接使用ThreadPoolExecutor的構(gòu)造方法來(lái)構(gòu)造了一個(gè)線程池蔽氨，來(lái)看一下參數(shù)：

• private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
  

  核心線程數(shù)，其中CPU_COUNT = Runtime.getRuntime().availableProcessors()表示CPU數(shù)量帆疟。最低兩個(gè)孵滞，最多四個(gè)。

• private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
  

  最大線程數(shù)鸯匹，是CPU核心數(shù)的2倍+1.

• private static final int KEEP_ALIVE_SECONDS = 30;
  

  空閑線程存活時(shí)間，30 泄伪。根據(jù)第四個(gè)參數(shù)TimeUnit.SECONDS知道是30秒殴蓬。

• private static final BlockingQueue<Runnable> sPoolWorkQueue =new LinkedBlockingQueue<Runnable>(128);
  

  使用了LinkedBlockingQueue，超過核心線程數(shù)量的任務(wù)會(huì)在隊(duì)列中排隊(duì)。

• 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());
      }
  };
  

  這個(gè)只是給每個(gè)線程池中創(chuàng)建的額線程起了個(gè)名字染厅，叫 AsyncTask # 數(shù)字痘绎，數(shù)字自增長(zhǎng)。

然后設(shè)置語(yǔ)序核心線程空閑超時(shí)threadPoolExecutor.allowCoreThreadTimeOut(true) 肖粮。

這是一個(gè)中規(guī)中矩的線程池孤页，然而默認(rèn)使用的線程池并不是這個(gè)。而是下面的SERIAL_EXECUTOR

SERIAL_EXECUTOR

SERIAL_EXECUTOR中維護(hù)了一個(gè)雙端數(shù)組隊(duì)列mTasks涩馆，里面存放的Runnable行施。

當(dāng)調(diào)用他的execute方法執(zhí)行Runnable時(shí)，他會(huì)把這個(gè)Runnable的run方法和scheduleNext()方法重新加工包裝成一個(gè)新的Runnable放在隊(duì)列中魂那。

然后下面會(huì)判斷mActive是不是空的蛾号，第一次肯定是空的，所以會(huì)執(zhí)行scheduleNext()方法涯雅。

在這個(gè)方法中鲜结，會(huì)調(diào)用隊(duì)列的poll方法取出一個(gè)Runnable,然后調(diào)用上面的線程池THREAD_POOL_EXECUTOR來(lái)執(zhí)行任務(wù)。

因?yàn)槊總€(gè)任務(wù)經(jīng)過加工都加上了scheduleNext()方法活逆，所以隊(duì)列中的任務(wù)都會(huì)按順序執(zhí)行完精刷。

• 由此可見，這個(gè)隊(duì)列僅僅起到一個(gè)排序功能蔗候，是各個(gè)任務(wù)依次執(zhí)行怒允，真正的執(zhí)行還是交給了線程池SERIAL_EXECUTOR.

AsyncTask的其他內(nèi)部類

狀態(tài)Status

AsyncTask有一個(gè)枚舉類定義了三個(gè)狀態(tài)：

public enum Status {
    /**
     * Indicates that the task has not been executed yet.
     * 表明任務(wù)尚未執(zhí)行
     */
    PENDING,
    /**
     * Indicates that the task is running.
     * 表明任務(wù)正在執(zhí)行
     */
    RUNNING,
    /**
     * Indicates that {@link AsyncTask#onPostExecute} has finished.
     * 表明onPostExecute已經(jīng)結(jié)束
     */
    FINISHED,
}

當(dāng)然就有一個(gè)表示狀態(tài)的變量,mStatus默認(rèn)是Status.PENDING:

private volatile Status mStatus = Status.PENDING;

WorkerRunnable

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

這個(gè)類就是個(gè)CallAble接口，里面增加了一個(gè)參數(shù)數(shù)組琴庵。

AsyncTaskResult

這個(gè)類其實(shí)就是個(gè)存儲(chǔ)類误算，保存了一個(gè)AsyncTask和Data[].

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

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

運(yùn)行過程

上面的都準(zhǔn)備好了，下面就能運(yùn)行了迷殿。

看著調(diào)用方法：

new MyAsyncTask().execute();

先實(shí)現(xiàn)一個(gè)AsyncTask,這時(shí)要定義三個(gè)參數(shù)類型儿礼，

AsyncTask<Params, Progress, Result> 

先new一個(gè)，然后調(diào)用execute方法

new的時(shí)候肯定會(huì)調(diào)用構(gòu)造方法

構(gòu)造方法

AsyncTask的構(gòu)造方法中初始化了兩個(gè)變量：

private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;
private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
public AsyncTask() {
    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);
            }
        }
    };
}

mWorker前面看到了庆寺，是一個(gè)WorkerRunnable蚊夫，所以要重寫call方法。

這個(gè)任務(wù)其實(shí)才是后臺(tái)任務(wù)懦尝，所以這個(gè)任務(wù)就是真正的AsyncTask的任務(wù)了知纷。

然后就調(diào)用了doInBackground(mParams)，把參數(shù)穿了進(jìn)去陵霉。

mFuture是個(gè)FutureTask琅轧，他把上面的mWorker又進(jìn)行了一次包裝，會(huì)先執(zhí)行mWorker的call方法中的內(nèi)容踊挠，再執(zhí)行done()乍桂。

execute

public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}

這個(gè)方法是真正開始執(zhí)行任務(wù)的方法，一般都會(huì)傳入個(gè)參數(shù)Params。

里面直接調(diào)用了executeOnExecutor(sDefaultExecutor, params)方法睹酌，使用的線程池是默認(rèn)的 权谁，也就是上面的SERIAL_EXECUTOR。串行執(zhí)行任務(wù)憋沿。

onPreExecute

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

這里先判斷任務(wù)的狀態(tài)mStatus旺芽，如果是正在運(yùn)行或者說(shuō)運(yùn)行結(jié)束了，都會(huì)拋異常辐啄。所以一個(gè)任務(wù)只能執(zhí)行一次executef方法采章，一個(gè)任務(wù)只能執(zhí)行一次，不能重復(fù)執(zhí)行则披。

當(dāng)mStatus是PENDING的時(shí)候共缕，先mStatus = Status.RUNNING表示任務(wù)正在執(zhí)行了。

然后就調(diào)用到了onPreExecute()方法士复。

mWorker.mParams = params前面看見WorkerRunnable中有一個(gè)變量Params[] mParams图谷，保存了傳入的參數(shù)。

一直到這時(shí)候都還是在原來(lái)的線程中運(yùn)行阱洪，并沒有開啟多線程便贵。所以這個(gè)方法也是在原來(lái)的線程中運(yùn)行的。

然后調(diào)用傳入的線程池的execute方法冗荸，來(lái)執(zhí)行構(gòu)造方法中新建的mFuture承璃。這個(gè)時(shí)候就使用線程池開新線程了。

doInBackground

mFuture里有個(gè)mWorker,會(huì)執(zhí)行他的call方法蚌本，這個(gè)方法中的內(nèi)容都會(huì)在子線程中運(yùn)行盔粹，其中包括了doInBackground，他的參數(shù)mParams是WorkerRunnable里的變量程癌。：

mWorker = new WorkerRunnable<Params, Result>() {
    public Result call() throws Exception {
        mTaskInvoked.set(true);
        Result result = null;
        try {
            ...
            result = doInBackground(mParams);
            ...
        } catch (Throwable tr) {
            mCancelled.set(true);
            throw tr;
        } finally {
            postResult(result);
        }
        return result;
    }
};

首先把mTaskInvoked設(shè)置為true表示這個(gè)任務(wù)已經(jīng)開始了舷嗡。

然后調(diào)用重寫過的doInBackground方法，運(yùn)行咱們需要后臺(tái)運(yùn)行的任務(wù)嵌莉。

doInBackground有一個(gè)返回值进萄，也是個(gè)泛型。

出現(xiàn)異常時(shí)锐峭，將mCancelled設(shè)置為true,表示任務(wù)取消了中鼠。

最終都會(huì)調(diào)用postResult(result)方法。

這個(gè)方法也很簡(jiǎn)單：

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

getHandler()前面知道是通過單例獲取到一個(gè)使用主線程Looper創(chuàng)建的Handler,就是InnerHandler,所以他對(duì)消息的處理會(huì)回到主線程中沿癞。

然后通過這個(gè)Handler發(fā)送消息援雇，消息內(nèi)容是new AsyncTaskResult<Result>(this, result)。前面也看了這是個(gè)載體椎扬，將這個(gè)AsyncTask本身和后臺(tái)任務(wù)doInBackground的返回結(jié)果傳了進(jìn)去熊杨。

然后整個(gè)工作就完成了曙旭。

onProgressUpdate

這個(gè)方法用來(lái)更新進(jìn)度，不能直接調(diào)用晶府，要通過publishProgress方法來(lái)調(diào)用。

在doInBackground钻趋，通常會(huì)手動(dòng)調(diào)用publishProgress方法來(lái)更新進(jìn)度

protected final void publishProgress(Progress... values) {
    if (!isCancelled()) {
        getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                new AsyncTaskResult<Progress>(this, values)).sendToTarget();
    }
}

這個(gè)方法賢惠判斷任務(wù)是否取消川陆，如果取消了就什么都不做。

沒取消就也用InnerHandler發(fā)送消息蛮位，內(nèi)容是new AsyncTaskResult<Progress>(this, values)较沪。傳入當(dāng)前的AsyncTask和進(jìn)度信息values.

這些方法最終都是以通過Handler發(fā)送個(gè)消息結(jié)束，所以后面的就是Handler的事了

之前已經(jīng)看過了這個(gè)類：

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中能看到失仁，result是個(gè)AsyncTaskResult類型尸曼，在前面也知道這個(gè)里面保存了AsyncTask和要傳遞的數(shù)據(jù)。前面兩個(gè)消息攜帶的信息也是這個(gè)類型萄焦。

當(dāng)msg.what==MESSAGE_POST_PROGRESS的時(shí)候控轿，表示要更新進(jìn)度，就先從result中拿到里面的AsyncTask->result.mTask拂封，然后調(diào)用他的onProgressUpdate方法茬射，參數(shù)是result中的mData->result.mData。

如果重寫過這個(gè)方法冒签，就可以根據(jù)這個(gè)值更新進(jìn)度在抛。

onPostExecute

當(dāng)msg.what==MESSAGE_POST_RESULT的時(shí)候，表示有結(jié)果了萧恕，這是后臺(tái)任務(wù)已經(jīng)執(zhí)行結(jié)束了刚梭。

調(diào)用里面的AsyncTask的finish方法，參數(shù)是消息里的mData票唆。

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

里面也是先判斷是否取消朴读，取消了就調(diào)用取消的回調(diào)onCancelled，沒取消就調(diào)用正常的回調(diào)onPostExecute惰说，并最后把任務(wù)狀態(tài)改為Status.FINISHED磨德。

整個(gè)任務(wù)結(jié)束。