Android源碼之AsyncTask 參考 1 AsyncTask簡單用法 2 源碼解讀 大致類關係圖 結語

參考

• 本文源碼版本：Pie 9.0.0_r3
• 在線源碼地址:AsyncTask.java

1 AsyncTask簡單用法

// 三個泛型參數分別代表傳入的參數類型，任務執行過程需要更新的數據類型，任務執行結束返回的結果類型，如果無類型則可以用Void類
        AsyncTask<Integer,Integer,Void> asyncTask = new AsyncTask<Integer, Integer, Void>() {
            /**
             * 得到結果，在主線程執行
             * @param aVoid
             */
            @Override
            protected void onPostExecute(Void aVoid) {
                Log.d(TAG, "onPostExecute: >>>");
                super.onPostExecute(aVoid);
            }

            /**
             * 任務內容，在工作線程執行
             * @param integers
             * @return
             */
            @Override
            protected Void doInBackground(Integer... integers) {
                Log.d(TAG, "doInBackground: >>>params: "+Arrays.toString(integers));
                return null;
            }

            /**
             * 任務執行前，在主線程執行
             */
            @Override
            protected void onPreExecute() {
                Log.d(TAG, "onPreExecute: >>");
                super.onPreExecute();
            }

            /**
             * 任務已取消（帶結果），在主線程執行
             * @param aVoid
             */
            @Override
            protected void onCancelled(Void aVoid) {
                super.onCancelled(aVoid);
                Log.d(TAG, "onCancelled（有參）: >>>");
            }

            /**
             * 任務已取消，在主線程執行
             */
            @Override
            protected void onCancelled() {
                super.onCancelled();
                Log.d(TAG, "onCancelled: >>>");
            }

            /**
             * 指定過程更新的數據，在主線程執行
             * @param values
             */
            @Override
            protected void onProgressUpdate(Integer... values) {
                super.onProgressUpdate(values);
                Log.d(TAG, "onProgressUpdate: "+ Arrays.toString(values));
            }
        };

        asyncTask.execute(2,3,1);

執行結果：

06-20 18:48:44.440 2761-2761/me.newtrekwang.customwidget D/TaskLibActivity: onPreExecute: >>
06-20 18:48:44.441 2761-2808/me.newtrekwang.customwidget D/TaskLibActivity: doInBackground: >>>params: [2, 3, 1]
06-20 18:48:44.454 2761-2761/me.newtrekwang.customwidget D/TaskLibActivity: onPostExecute: >>>

2 源碼解讀

2.1 線程池大小相關

    /**
     * cpu核心數
     */
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    /**
     * 核心線程：至少兩個線程，最多4個線程。 
     */
    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;

怎麼分配線程池合理？

一般來說，設N爲CPU核數。

• 如果是CPU密集型應用，則線程池大小設置爲N+1.
• 如果是IO密集型應用，則線程池大小設置爲N*2+1

IO密集型

I/O bound 指的是系統的CPU效能相對硬盤/內存的效能要好很多，此時，系統運作，大部分的狀況是 CPU 在等 I/O (硬盤/內存) 的讀/寫，此時 CPU Loading 不高。

CPU密集型

CPU bound 指的是系統的 硬盤/內存 效能 相對 CPU 的效能 要好很多，此時，系統運作，大部分的狀況是 CPU Loading 100%，CPU 要讀/寫 I/O (硬盤/內存)，I/O在很短的時間就可以完成，而 CPU 還有許多運算要處理，CPU Loading 很高。

Android 應用的話應該是屬於IO密集型應用，所以數量一般設置爲 2N+1，AsyncTask裏執行任務的線程池也是這樣設置的。

2.2 兩個線程池

在AsyncTask中有兩個線程池，一個線程池（SerialExecutor）用於處理任務列表，一個線程池(ThreadPoolExecutor)用於執行任務。

構建用於執行任務的ThreadPoolExecutor

/**
     * 處理任務的線程池
     */
    public static final Executor THREAD_POOL_EXECUTOR;
    /**
     * 任務隊列
     */
    private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingDeque<>(128);
    /**
     * 線程工廠
     */
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        /**
         * 線程安全的計數器
         */
        private final AtomicInteger mCount = new AtomicInteger(1);
        
        @Override
        public Thread newThread(@NonNull Runnable runnable) {
            return new Thread(runnable,"AsyncTask #"+mCount.getAndIncrement());
        }
    };
    
    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;
    }

構建用於任務排隊的SerialExecutor

    /**
     * 串行任務執行器
     */
    private static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    /**
     * 默認任務執行器
     */
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    /**
     * @className WangAsyncTask
     * @createDate 2019/6/20 17:52
     * @author newtrekWang
     * @email [email protected]
     * @desc 串行任務執行器類
     *
     */
    private static class SerialExecutor implements Executor{
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<>();
        Runnable mActive;
        @Override
        public synchronized void execute(@NonNull final Runnable runnable) {
            // 入隊一個runnable,對原始的runnable加了點修飾
            mTasks.offer(new Runnable() {
                @Override
                public void run() {
                    try {
                        runnable.run();
                    } finally {
                        // 任務執行後，要檢查是否有下一個runnable需要執行
                        scheduleNext();
                    }
                }
            });
            // 第一次的時候需要觸發下才能執行
            if (mActive == null){
                scheduleNext();
            }
        }

        /**
         * 檢查是否有下一個runnable需要執行，如果有，則交給另一個線程池執行
         */
        protected synchronized void scheduleNext(){
            if ((mActive = mTasks.poll()) != null){
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

爲什麼用兩個線程池？

因爲AsyncTask是設計爲串行執行任務的，所以另外最好需要一個線程池負責任務的排隊。

2.3 任務執行流程

2.3.1 構造AsyncTask

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

AsynckTask有關鍵的三個成員：mHandler,mWorker,mFuture

mHandler

用於線程間通信，將工作線程的消息傳遞到主線程並做出處理，也就是實現AsyncTask過程數據回調，結果回調在主線程的關鍵。

    private static Handler getMainHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler(Looper.getMainLooper());
            }
            return sHandler;
        }
    }

然後再看InternalHandler類:

    private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);
        }

        @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 class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

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

AsyncTaskResult裏包含的AsynTask對象的引用。

Handler可以從收到的msg裏得到統一的AsynctTaskResult數據對象，然後根據消息類型，進行處理。

比如MESSAGE_POST_RESULT是工作線程傳的已完成任務標誌，然後此時AsyncTask的結束回調方法應該被調用，通過result.mTask.finish(result.mData[0])既可以實現結束回調，使AsyncTask使用者可以從回調種拿到結果。

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

另外MESSAGE_POST_PROGRESS就是過程中工作線程傳的更新消息。也一樣通過result.mTask.onProgressUpdate(result.mData)實現在Handler所在線程更新過程數據。

mWorker

mWorker就是一個Callable，即有返回結果的Runable,而它的實現類WorkerRunnable還帶上了任務參數Params。

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

通過上面代碼可以知道，用戶實現的doInBackground(mParams)方法就是在這裏調用的，相當於是把用戶的業務代碼包裝成一個Callable，然後再包裝成FutureTask，接着將FutureTask提交給線程池，這樣來實現在工作線程執行用戶定義的代碼塊。

然後具體分析call()方法：首先mTaskInvoked是一個AtomicBoolean對象，它能保證線程安全地更新boolean值，mTaskInvoked.set(true)表示該AsyncTask對象已被調用。然後就是設置當前線程的優先級Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND)。然後就是調用用戶實現的doInBackground(mParams)方法。然後Binder.flushPendingCommands();是一個native方法，應該是重新調整線程優先級的。然後是捕獲異常，最後是通過postResult(result)提交結果到主線程。

// 提交結果到Handler所在線程
    private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

// 提交更新數據到Handler所在線程
    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }

mFuture

如果單單是提交callable到線程池執行有callable就完事了,但是還需要支持任務的取消操作，那麼這個功能就需要FutureTask了。

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

mFuture就是mWorker的一個包裝類，它也具體實現了Future的一些任務操作接口，比如取消任務，mFuture重寫了done()方法，應該是考慮到AsyncTask的get()和cancel()方法內部出異常時對結果的處理。

至於FutureTask是怎樣實現取消和get()阻塞得到結果的，我會在另一篇文字做介紹。

2.3.2 execute():執行AsyncTask

execute(Params... params)是AsyncTask爲使用者提供的API，它的具體實現如下：

關鍵代碼：

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

        return this;
    }

可以看出executor方法實際及時調用executeOnExecutor方法，如果用AsyncTask默認的串行執行任務的線程池就用executor()，默認線程池就是前面提到的sDefaultExecutor，如果是自定義線程池，就用executeOnExecutor()。

然後看executeOnExecutor方法:首先會判斷status，如果是RUNNING和FINISHED，會拋異常，也驗證了一個AsyncTask只能被執行一次。

然後更新狀態爲RUNNING,調用onPreExecute(),因爲execute（）是在主線程調用的，此時onPreExecute()就是在主線程執行的。然後將用戶傳的mParams注入mWorker，最後再將future提交到線程池執行。

通過這些代碼分析可以得出：一個任務對應一個AsyncTask,一個AsyncTask對應一個Worker,一個Worker對應一個FutureTask,然後多個AsyncTask共用兩個默認的線程池和InternalHandler。

大致類關係圖

結語

分析到這裏，AsyncTask其實也並不複雜，它始終還是用的線程池+Handler機制來設計的，只要理解了其中的設計步驟，我們自己也可以定義一個AsyncTask。

平時在業務開發中根本就接觸不到併發編程知識，只知道使用別人的框架，這對於個人技術提高並沒有什麼進步。

在AsyncTask中我就瞭解到了：

• 線程池的線程數該如何設置？怎樣定義線程池？
• 怎樣使用線程池？
• Handler機制
• FutureTask，RunnableFuture，Callable，Runnable，Future之間的關係
• 怎樣實現任務的取消？

感覺這些知識點都是通用的，理解了這些問題後再去看其它框架源碼或設計一個框架，自己心裏也有一個方案。