AsyncTask源碼解析干貨

前言

好久沒看過源碼了，前幾天面試被問到一臉懵逼，全忘掉了。復(fù)習一下，做個筆記分享。AsyncTask是android開發(fā)中一個非常重要的異步類，可以在異步線程中做一些耗時的操作。本文參照源碼對AsyncTask進行簡單的解析。

一、AsyncTask簡介及基本使用。

1、AsyncTask簡介

??AsyncTask是對針對Handler+線程池的封裝，可以在異步的去更新UI，使用方式簡單便捷，僅需要繼承AsyncTask抽象類，并實現(xiàn)幾個基本方法即可，需要注意的是必須要在UI線程進行調(diào)用，因為AsyncTask使用的Handler為UI線程 下的Handler，只有這樣才可以在子線程去更新UI線程。
??AsyncTask類的聲明如下：

public abstract class AsyncTask<Params, Progress, Result>

其中：
?Params為傳入到doInBackground方法的參數(shù)類型；
?Progress為進度條所使用的參數(shù)類型；
?Result為線程完成后返回值的參數(shù)類型；
AsyncTask主要的方法有五個：

onPreExecute() : 在線程池開始進行任務(wù)之前調(diào)用，為準備工作

doInBackground(Params… params) ：線程中進行的工作，唯一一個在子線程運行的方法

onProgressUpdate(Progress… values)：顯示線程中工作進度，調(diào)用方法在doInBackground中的
publishProgress方法

onPostExecute(Result result) ：線程結(jié)束后會通過handler調(diào)用到onPostExecute方法，并返回結(jié)果

cancel(boolean mayInterruptIfRunning)：中途打斷線程運行，但不一定會成功。如果任務(wù)已經(jīng)完成，
則無論mayInterruptIfRunning為true還是false，此方法肯定返回false，即如果取消已經(jīng)完成的任務(wù)會
返回false；如果任務(wù)正在執(zhí)行，若mayInterruptIfRunning設(shè)置為true，則返回true，若mayInterruptI
fRunning設(shè)置為false，則返回false；如果任務(wù)還沒有執(zhí)行，則無論mayInterruptIfRunning為true還是
false，肯定返回true。

2、AsyncTask注意事項

1、AsyncTask并不會隨Activiy關(guān)閉而取消，doInbackground依然會運行，直到線程結(jié)束后會調(diào)用finish()方法，如果在關(guān)閉前調(diào)用過cancel()方法，會調(diào)onCancelled()方法，如果沒有的話，會直接跳轉(zhuǎn)OnPostExecute()方法，可能會導致AsyncTask報錯崩潰。

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

2、如果屏幕旋轉(zhuǎn)或其他方式導致Activity重新創(chuàng)建，那么AsyncTask所持有的Activity中的引用會失效，OnPostExecute()方法繪制的時候?qū)⒉粫行Ч?br> 3、要注意并行和串行，分別由execute()和executeOnExecutor(Executor)控制。

3、源碼分析

AsyncTask構(gòu)造器：

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

                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
                Result result = doInBackground(mParams);
                Binder.flushPendingCommands();
                return postResult(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);
                }
            }
        };
    }

很明顯，在構(gòu)造器中new了兩個對象，分別為WorkerRunnable和FutureTask（FutrueTask為java并發(fā)編程中一個比較重要類，如果不了解的話，請百度一下，或者看我下一篇文章）。doInBackground()方法在mWorker的call()方法中被調(diào)用，且返回值在postResult()方法中被調(diào)用。
我們來看一下WorkerRunnable類的源碼和FutureTask的構(gòu)造方法。

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

 public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

很明顯，WorkerRunnable類實現(xiàn)了Callable的接口。被FutureTask作為參數(shù)傳入。這就說明doInbackground()實際是在異步線程中被調(diào)用。且實際上AsyncTask的成員mWorker包含了AyncTask要執(zhí)行的任務(wù)。那么mWorker的call()方法到底什么時候會被調(diào)用呢，了解過FutureTask運行機制的朋友都知道FutureTask只有被放到線程池中的時候才會被調(diào)用，進而調(diào)用到call()方法。
在看一下剛剛注意事項里說道的execute()方法的源碼：

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

由源碼可以，該方法僅能在主線程中使用，另外execute返回的是executeOnExecutor方法的返回值，參數(shù)為sDefaultExecutor和params。
首先來看下executeOnExecutor方法：

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

第一個參數(shù)為線程調(diào)度的對象，第二個參數(shù)為mWorker的mParams參數(shù)，由上面的源碼可知，mParams參數(shù)是傳到doInBackground中的。另外executeOnExecutor()方法中還調(diào)用了onPreExecute()，之后才會調(diào)用exec.execute(mFuture);說明onPreExecute方法的確是在主線程中調(diào)用，且在子線程開始之前調(diào)用。
我們再看看sDefaultExecutor參數(shù)：

 public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
 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);
            }
        }
    }

很簡單，sDefaultExecutor 為SerialExecutor類 的一個對象，且標識為volatile，以防止線程問題。SerialExecutor 的實現(xiàn)中可以看到，線程池維持了一個Runnable的隊列。mActive為正在運行的線程，當調(diào)用execute()方法時在隊列末尾插入需要運行的Runnable對象。并調(diào)用scheduleNext();方法。如果當前運行的Runnable對象為空的話，會繼續(xù)調(diào)用scheduleNext()，在scheduleNext()方法中可以看到首先mTasks出隊給mActive賦值，如果不為空，則
??THREAD_POOL_EXECUTOR.execute(mActive)
我們來看一下THREAD_POOL_EXECUTOR是什么

  /**
     * An {@link Executor} that can be used to execute tasks in parallel.
     */
    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;
    }

可以看出來THREAD_POOL_EXECUTOR是一個線程池對象，為真正開始異步邏輯的載體。

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    // We want at least 2 threads and at most 4 threads in the core pool,
    // preferring to have 1 less than the CPU count to avoid saturating
    // the CPU with background work
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;

由注釋可以看出，編寫者希望線程池基本大小(CORE_POOL_SIZE )最少為2個線程，最多為4個線程，來維持線程池的運轉(zhuǎn)，只有在隊列滿的時候才會創(chuàng)建更多的線程。線程池中允許的最大線程數(shù)(MAXIMUM_POOL_SIZE )為CPU的數(shù)目的2倍+1,線程空閑時超時時間(KEEP_ALIVE_SECONDS )為30s。
另外在上面說過當WorkerRunnable任務(wù)做完的時候會調(diào)用postResult()方法?？匆幌略创a

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

當任務(wù)做完的時候會發(fā)送message到Handler中處理

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

如果為MESSAGE_POST_RESULT，則會調(diào)用finish()方法，在上文中已經(jīng)說到過該方法，由構(gòu)造方法可以看出，InternalHandler使用的為主線程的looper，故而可以在handleMessage中刷新UI。
另外還有一個publishProgress：

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

也是通過message通知handler刷新UI。

如果有什么問題歡迎留言或給我發(fā)郵件 tlioylc@gmail.com
良心干貨，歡迎關(guān)注

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容