摘要：異步任務(wù)的構(gòu)造方法主要用于初始化線程池先關(guān)的成員變量創(chuàng)建一個(gè)新的異步任務(wù)。所以，我們是必須確保在銷毀活動之前取消任務(wù)。

01.先看下AsyncTask用法

02.AsyncTask源碼深入分析

2.1 構(gòu)造方法源碼分析

2.2 看execute(Params... params)方法

2.3 mWorker和mFuture的創(chuàng)建過程

03.異步機(jī)制的實(shí)現(xiàn)

04.不同的SDK版本區(qū)別

05.AsyncTask的缺陷和問題

5.1 AsyncTask對應(yīng)線程池

5.2 AsyncTask生命周期問題

5.3 AsyncTask內(nèi)存泄漏問題

5.4 AsyncTask結(jié)果丟失問題

5.5 AsyncTask并行還是串行問題

博客筆記大匯總【16年3月到至今】，包括Java基礎(chǔ)及深入知識點(diǎn)，Android技術(shù)博客，Python學(xué)習(xí)筆記等等，還包括平時(shí)開發(fā)中遇到的bug匯總，當(dāng)然也在工作之余收集了大量的面試題，長期更新維護(hù)并且修正，持續(xù)完善……開源的文件是markdown格式的！同時(shí)也開源了生活博客，從12年起，積累共計(jì)47篇[近20萬字]，轉(zhuǎn)載請注明出處，謝謝！

鏈接地址：https://github.com/yangchong2...

如果覺得好，可以star一下，謝謝！當(dāng)然也歡迎提出建議，萬事起于忽微，量變引起質(zhì)變！

AsyncTask是如何實(shí)現(xiàn)異步機(jī)制的，底層原理是什么？

AsyncTask調(diào)用execute方法時(shí)，如果不是運(yùn)行在主線程中會出現(xiàn)什么情況，如何解決？

為什么異步任務(wù)對象不能執(zhí)行多次，即不能創(chuàng)建一個(gè)對象執(zhí)行多次execute方法？

doInBackground這個(gè)方法可以做什么操作？它是在主線程中還是工作線程中？為什么？

AsyncTask任務(wù)是否可以被中途取消？為什么？

AsyncTask對應(yīng)線程池是如何操作的？它有什么弊端，為什么現(xiàn)在幾乎很少用呢？

AsyncTask的執(zhí)行策略是并行還是串行的？

帶著問題去看這篇文章，相信看完之后你對異常AsyncTask有了初步理解……

來看一下AsyncTask的基本使用，代碼如下所示

定義了自己的MyAsyncTask并繼承自AsyncTask；并重寫了其中的是哪個(gè)回調(diào)方法：onPreExecute()，onPostExecute（），doInBackground();

class MyAsyncTask extends AsyncTask {
    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        Log.i(TAG, "onPreExecute...(開始執(zhí)行后臺任務(wù)之前)");
    }

    @Override
    protected void onPostExecute(Integer i) {
        super.onPostExecute(i);
        Log.i("TAG", "onPostExecute...(開始執(zhí)行后臺任務(wù)之后)");
    }

    @Override
    protected Integer doInBackground(Integer... params) {
        Log.i(TAG, "doInBackground...(開始執(zhí)行后臺任務(wù))");
        return 0;
    }
}

開始調(diào)用異步任務(wù)

new MyAsyncTask().execute();

源代碼如下所示，主要是看AsyncTask(@Nullable Looper callbackLooper)中的代碼

這里面只是初始化了兩個(gè)成員變量：mWorker和mFuture他們分別是：WorkerRunnable和FutureTask，對于熟悉java的逗比應(yīng)該知道這兩個(gè)類其實(shí)是java里面線程池先關(guān)的概念。

異步任務(wù)的構(gòu)造方法主要用于初始化線程池先關(guān)的成員變量

//創(chuàng)建一個(gè)新的異步任務(wù)。必須在UI線程上調(diào)用此構(gòu)造函數(shù)
public AsyncTask() {
    this((Looper) null);
}

//創(chuàng)建一個(gè)新的異步任務(wù)。必須在UI線程上調(diào)用此構(gòu)造函數(shù)
public AsyncTask(@Nullable Handler handler) {
    this(handler != null ? handler.getLooper() : null);
}

public AsyncTask(@Nullable Looper callbackLooper) {
    mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
        ? getMainHandler()
        : new Handler(callbackLooper);

    mWorker = new WorkerRunnable() {
        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(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);
            }
        }
    };
}

看一下execute方法

發(fā)現(xiàn)該方法中添加一個(gè)@MainThread的注解，通過該注解，可以知道我們在執(zhí)行AsyncTask的execute方法時(shí)，只能在主線程中執(zhí)行

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

如果execute方法不是運(yùn)行在主線程中會出現(xiàn)什么情況呢？

執(zhí)行，但是并沒有什么區(qū)別，程序還是可以正常執(zhí)行。但是onPreExecute方法是與開始執(zhí)行的execute方法是在同一個(gè)線程中的，所以如果在子線程中執(zhí)行execute方法，一定要確保onPreExecute方法不執(zhí)行刷新UI的方法，否則將會拋出異常。

new Thread(new Runnable() {
    @Override
    public void run() {
        Log.i("tag", Thread.currentThread().getId() + "");
        new MAsyncTask().execute();
    }
}).start();
Log.i("tag", "mainThread:" + Thread.currentThread().getId() + "");

@Override
protected void onPreExecute() {
    super.onPreExecute();
    //更新UI
    title.setText("瀟湘劍雨");
    Log.i(TAG, "onPreExecute...(開始執(zhí)行后臺任務(wù)之前)");
}

異常如下所示，在子線程中執(zhí)行execute方法，那么這時(shí)候如果在onPreExecute方法中刷新UI，會報(bào)錯(cuò)，即子線程中不能更新UI。

Process: com.example.aaron.helloworld, PID: 659
android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

接著看看executeOnExecutor這個(gè)方法源碼

具體的內(nèi)部實(shí)現(xiàn)方法里：首先判斷當(dāng)前異步任務(wù)的狀態(tài)，其內(nèi)部保存異步任務(wù)狀態(tài)的成員變量mStatus的默認(rèn)值為Status.PENDING,所以第一次執(zhí)行的時(shí)候并不拋出這兩個(gè)異常，那么什么時(shí)候回進(jìn)入這個(gè)if判斷并拋出異常呢，通過查看源代碼可以知道，當(dāng)我們執(zhí)行了execute方法之后，如果再次執(zhí)行就會進(jìn)入這里的if條件判斷并拋出異常

在executeOnExecutor中若沒有進(jìn)入異常分之，則將當(dāng)前異步任務(wù)的狀態(tài)更改為Running，然后回調(diào)onPreExecute()方法，這里可以查看一下onPreExecute方法其實(shí)是一個(gè)空方法，主要就是為了用于我們的回調(diào)實(shí)現(xiàn)，同時(shí)這里也說明了onPreExecute（）方法是與execute方法的執(zhí)行在同一線程中。

然后將execute方法的參數(shù)賦值給mWorker對象那個(gè)，最后執(zhí)行exec.execute(mFuture)方法，并返回自身。

模擬測試一下拋出異常的操作

看到我們定義了一個(gè)AsyncTask的對象，并且每次執(zhí)行點(diǎn)擊事件的回調(diào)方法都會執(zhí)行execute方法，當(dāng)我們點(diǎn)擊第一次的時(shí)候程序正常執(zhí)行，但是當(dāng)我們執(zhí)行第二次的時(shí)候，程序就崩潰了。

final MyAsyncTask mAsyncTask = new MyAsyncTask();
title.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Log.i("tag", Thread.currentThread().getId() + "");
                mAsyncTask.execute();
            }
        }).start();
        Log.i("tag", "mainThread:" + Thread.currentThread().getId() + "");
    }
});

若這時(shí)候第一次執(zhí)行的異步任務(wù)尚未執(zhí)行完成則會拋出異常：

Cannot execute task:the task is already running.

若第一次執(zhí)行的異步任務(wù)已經(jīng)執(zhí)行完成，則會拋出異常：

Cannot execute task:the task has already been executed (a task can be executed only once)

然后看一下exec.execute(mFuture)的實(shí)現(xiàn)

這里的exec其實(shí)是AsyncTask定義的一個(gè)默認(rèn)的Executor對象：

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

那么，SERIAL_EXECUTOR又是什么東西呢？

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

繼續(xù)查看SerialExecutor的具體實(shí)現(xiàn)：

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

可以發(fā)現(xiàn)其繼承Executor類其內(nèi)部保存著一個(gè)Runnable列表，即任務(wù)列表，在剛剛的execute方法中執(zhí)行的exec.execute(mFuture)方法就是執(zhí)行的這里的execute方法。

這里具體看一下execute方法的實(shí)現(xiàn)：

1）首先調(diào)用的是mTasks的offer方法，即將異步任務(wù)保存至任務(wù)列表的隊(duì)尾

2）判斷mActive對象是不是等于null，第一次運(yùn)行是null，然后調(diào)用scheduleNext()方法

3）在scheduleNext()這個(gè)方法中會從隊(duì)列的頭部取值，并賦值給mActive對象，然后調(diào)用THREAD_POOL_EXECUTOR去執(zhí)行取出的取出的Runnable對象。

4）在這之后如果再有新的任務(wù)被執(zhí)行時(shí)就等待上一個(gè)任務(wù)執(zhí)行完畢后才會得到執(zhí)行，所以說同一時(shí)刻只會有一個(gè)線程正在執(zhí)行。

5）這里的THREAD_POOL_EXECUTOR其實(shí)是一個(gè)線程池對象。

看一下執(zhí)行過程中mWorker的執(zhí)行邏輯：

可以看到在執(zhí)行線程池的任務(wù)時(shí)，我們回調(diào)了doInBackground方法，這也就是我們重寫AsyncTask時(shí)重寫doInBackground方法是后臺線程的原因。

mWorker = new WorkerRunnable() {
    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);
    }
};

看一下執(zhí)行過程中mFuture的執(zhí)行邏輯

mFuture = new FutureTask(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);
        }
    }
};

這里具體看一下postResultIfNotInvoked方法：

private void postResultIfNotInvoked(Result result) {
    final boolean wasTaskInvoked = mTaskInvoked.get();
    if (!wasTaskInvoked) {
        postResult(result);
    }
}

其內(nèi)部還是調(diào)用了postResult方法：

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

這里可以看到起調(diào)用了內(nèi)部的Handler對象的sendToTarget方法，發(fā)送異步消息

看AsyncTask內(nèi)部定義了一個(gè)Handler對象

內(nèi)部的handleMessage方法，有兩個(gè)處理邏輯，分別是：更新進(jìn)入條和執(zhí)行完成，這里的更新進(jìn)度的方法就是我們重寫AsyncTask方法時(shí)重寫的更新進(jìn)度的方法，這里的異步任務(wù)完成的消息會調(diào)用finish方法

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:
                result.mTask.finish(result.mData[0]);
                break;
            case MESSAGE_POST_PROGRESS:
                result.mTask.onProgressUpdate(result.mData);
                break;
        }
    }
}

然后看看調(diào)用finish方法做了什么

首先會判斷當(dāng)前任務(wù)是否被取消，若被取消的話則直接執(zhí)行取消的方法，否則執(zhí)行onPostExecute方法，也就是我們重寫AsyncTask時(shí)需要重寫的異步任務(wù)完成時(shí)回調(diào)的方法。

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

既然有處理消息的，那么肯定有發(fā)送消息的。

可以從構(gòu)造方法中看到，當(dāng)通過執(zhí)行doInBackground方法拿到結(jié)果后，最后在finally執(zhí)行發(fā)送該消息邏輯

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

可以看到MESSAGE_POST_PROGRESS這個(gè)消息發(fā)送是處理進(jìn)度，需要在工作線程中

@Override
protected ReusableBitmap doInBackground(Void... params) {
    // enqueue the "onDecodeBegin" signal on the main thread
    publishProgress();
    return decode();
}

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

調(diào)用AsyncTask的execute方法不能立即執(zhí)行程序的原因析及改善方案通過查閱官方文檔發(fā)現(xiàn)，AsyncTask首次引入時(shí)，異步任務(wù)是在一個(gè)獨(dú)立的線程中順序的執(zhí)行，也就是說一次只執(zhí)行一個(gè)任務(wù)，不能并行的執(zhí)行，從1.6開始，AsyncTask引入了線程池，支持同時(shí)執(zhí)行5個(gè)異步任務(wù)，也就是說時(shí)只能有5個(gè)線程運(yùn)行，超過的線程只能等待，等待前的線程某個(gè)執(zhí)行完了才被調(diào)度和運(yùn)行。換句話說，如果個(gè)進(jìn)程中的AsyncTask實(shí)例個(gè)數(shù)超過5個(gè)，那么假如前5都運(yùn)行很長時(shí)間的話，那么第6個(gè)只能等待機(jī)會了。這是AsyncTask的一個(gè)限制，而且對于2.3以前的版本無法解決。如果你的應(yīng)用需要大量的后臺線程去執(zhí)行任務(wù)，那么只能放棄使用AsyncTask，自己創(chuàng)建線程池來管理Thread。不得不說，雖然AsyncTask較Thread使用起來方便，但是它最多只能同時(shí)運(yùn)行5個(gè)線程，這也大大局限了它的作用，你必須要小心設(shè)計(jì)你的應(yīng)用，錯(cuò)開使用AsyncTask時(shí)間，盡力做到分時(shí)，或者保證數(shù)量不會大于5個(gè)，否就會遇到上次提到的問題?？赡苁荊oogle意識到了AsynTask的局限性了，從Android3.0開始對AsyncTask的API做出了一些調(diào)整：每次只啟動一個(gè)線程執(zhí)行一個(gè)任務(wù)，完了之后再執(zhí)行第二個(gè)任務(wù)，也就是相當(dāng)于只有一個(gè)后臺線在執(zhí)行所提交的任務(wù)。

Asynctask對應(yīng)的線程池ThreadPoolExecutr都是進(jìn)程范圍內(nèi)共享的，都是static的，所以是Asynctask控制著進(jìn)程范圍內(nèi)所有的子類實(shí)例。由于這個(gè)限制的存在，當(dāng)使用默認(rèn)線程池時(shí)，如果線程數(shù)超過線程池的最大容量，線程池就會爆掉(3.0后默認(rèn)串行執(zhí)行，不會出現(xiàn)個(gè)問題)。針對這種情況，可以嘗試自定義線程池，配合Asynctask使用。

關(guān)于默認(rèn)線程池：

AsyncTask里面線程池是一個(gè)核心線程數(shù)為CPU + 1，最大線程數(shù)為CPU * 2 + 1，工作隊(duì)列長度為128的線程池，線程等待隊(duì)列的最大等待數(shù)為28，但是可以自定義線程池。線程池是由AsyncTask來處理的，線程池允許tasks并行運(yùn)行，需要注意的是并發(fā)情況下數(shù)據(jù)的一致性問題，新數(shù)據(jù)可能會被老數(shù)據(jù)覆蓋掉類似volatile變量。所以希望tasks能夠串行運(yùn)行的話，使用SERIAL_EXECUTOR。

很多開發(fā)者會認(rèn)為一個(gè)在Activity中創(chuàng)建的AsyncTask隨著Activity的銷毀而銷毀。然而事實(shí)并非如此。AsynTask會一直執(zhí)行，直到doInBackground()方法執(zhí)行完畢，然后，如果cancel(boolean)被調(diào)用,那么onCancelled(Result result)方法會被執(zhí)行；否則，執(zhí)行onPostExecuteResult result)方法。如果我們的Activity銷毀之前，沒有取消AsyncTask，這有可能讓我們的應(yīng)用崩潰(crash)。因?yàn)樗胍幚淼膙iew已經(jīng)不存在了。所以，我們是必須確保在銷毀活動之前取消任務(wù)?？傊覀兪褂肁syncTask需要確保AsyncTask正確的取消。

如果AsyncTask被聲明為Activity的非靜態(tài)的內(nèi)部類，那么AsyncTask會保留一個(gè)對Activity的引用。如果Activity已經(jīng)被銷毀，AsyncTask的后臺線程還在執(zhí)行，它將續(xù)在內(nèi)存里保留這個(gè)引用，導(dǎo)致Activity無法被回收，引起內(nèi)存泄漏。

屏幕旋轉(zhuǎn)或Activity在后臺被系統(tǒng)殺掉等情況會導(dǎo)致Actvity的重新創(chuàng)建，之前運(yùn)行的AsyncTask會持有一個(gè)之前Activity的引用，這個(gè)引用已經(jīng)無效，這時(shí)調(diào)用onPostExecute()再去更新界面將不再生效。

在Android1.6之前的版本，AsyncTask是串行的，在1.6-2.3的版本，改成了并行的。在2.3之后的版本又做了修改，可以支持并行和串行，當(dāng)想要串行執(zhí)行時(shí)，直接行execute()方法，如果需要并行執(zhí)行時(shí)，執(zhí)行executeOnExecutor(Executor)。

1.技術(shù)博客匯總

2.開源項(xiàng)目匯總

3.生活博客匯總

4.喜馬拉雅音頻匯總

5.其他匯總

我的個(gè)人站點(diǎn)：www.yczbj.org，www.ycbjie.cn

github：https://github.com/yangchong211

知乎：https://www.zhihu.com/people/...

簡書：http://www.jianshu.com/u/b7b2...

csdn：http://my.csdn.net/m0_37700275

喜馬拉雅聽書：http://www.ximalaya.com/zhubo...

開源中國：https://my.oschina.net/zbj161...

泡在網(wǎng)上的日子：http://www.jcodecraeer.com/me...

郵箱：[email protected]

阿里云博客：https://yq.aliyun.com/users/a... 239.headeruserinfo.3.dT4bcV

segmentfault頭條：https://segmentfault.com/u/xi...