Template 設計模式 | 實現與解說 | Android source AsyncTask 微框架

也就是說 AsyncTask 物件不能重複使用，屬於一個拋棄式物件

// AsyncTask.java

public enum Status {
    /**
     * Indicates that the task has not been executed yet.
     */
    PENDING,
    /**
     * Indicates that the task is running.
     */
    RUNNING,
    /**
     * Indicates that {@link AsyncTask#onPostExecute} has finished.
     */
    FINISHED,
}

我們可以發現 sDefaultExecutor 是一個執行器（代表它可以執行某些任務），而任務的執行方案「預設採用順序式執行, ArrayDeque」

而最終任務會交給線程池 ThreadPoolExecutor 執行（說明請看註解）

// AsyncTask.java

public static final Executor THREAD_POOL_EXECUTOR;

static {
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
            // SynchronousQueue 的特色是一次只執行一個任務
            new SynchronousQueue<Runnable>(), sThreadFactory);
   
     // 拒絕策略設置（這邊就不分析了）
    threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);
    THREAD_POOL_EXECUTOR = threadPoolExecutor;
}


private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

private static class SerialExecutor implements Executor 
    // ArrayDeque 是 Java 中的雙向隊列
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
    Runnable mActive;

    public synchronized void execute(final Runnable r) {
        // 向隊列中添加 Runnalbe 任務
        mTasks.offer(new Runnable() {    // 最終線程池執行起來後，會運行這個任務
            public void run() {
                try {    
                    // 執行任務，也就是我們傳入的 mTask
                    r.run();        
                } finally {
                    // 運行完後，執行下一個任務
                    scheduleNext();
                }
            }
        });
        if (mActive == null) {
            scheduleNext();
        }
    }

    protected synchronized void scheduleNext() {
        if ((mActive = mTasks.poll()) != null) {
            THREAD_POOL_EXECUTOR.execute(mActive);
        }
    }
}

mFuture 成員是在建構函數時就被賦予值，以下的程式看似雜亂… 但其實在這裡的 重點是，它會把執行序（線程）切換到背景，並去執行模板中的 doInBackground 方法

// AsyncTask.java

private final FutureTask<Result> mFuture;

// 原子操作
private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

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 {
            // 將線程的優先級設置為 background 優先級                       
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
                result = doInBackground(mParams);

                ... 省略部份
            } catch (Throwable tr) {
                mCancelled.set(true);
                throw tr;
            } finally {
                // 將執行結果傳入 postResult
                postResult(result);
            }
            return result;
        }
    };

    mFuture = new FutureTask<Result>(mWorker) {
        @Override
        protected void done() {
            try {
                // 取得執行結果，並傳入 postResultIfNotInvoked 函數
                postResultIfNotInvoked(get());
            }  
            ... 省略 catch
        }
    };
}

這裡的 postResult 函數、postResultIfNotInvoked 函數，兩者其實都是做同一件事，就是「將結果丟到 Handler 中」，準備回傳結果！ 這裡我們直接看 postResult 函數，可以看到它將結果包裝到 AsyncTaskResult 類中，並丟入 Handler 開始傳送結果

// AsyncTask.java

private static final int MESSAGE_POST_RESULT = 0x1;

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

private static class AsyncTaskResult<Data> {
    final AsyncTask mTask;
    // 透過 Array 儲存結果
    final Data[] mData;

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