Android進階——多執行緒系列之非同步任務AsyncTask的使用與原始碼分析

阿新 • • 發佈：2019-02-01

AsyncTask是什麼

AsyncTask是一種輕量級的非同步任務類，它可以線上程池中執行後臺任務，然後把執行的進度和最終結果傳遞給主執行緒並主執行緒中更新UI，通過AsyncTask可以更加方便執行後臺任務以及在主執行緒中訪問UI，但是AsyncTask並不適合進行特別耗時的後臺任務，對於特別耗時的任務來說，建議使用執行緒池

AsyncTask的使用

我們簡單的模擬下載檔案的案例來分析，我們建立自己的非同步類繼承AsyncTask

private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> { 


    @Override
    protected void onPreExecute() {
        //非同步任務開啟之前回調，在主執行緒中執行
        super.onPreExecute();
    }

    @Override
    protected Long doInBackground(URL... urls) {
        //執行非同步任務，線上程池中執行
        long totalSize = 0;
        int i = 0;
        try {
            while (i < 100) {
                Thread.sleep(50 
);
                i = i + 5;
                publishProgress(i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        totalSize = totalSize + i;
        return totalSize;
    }

    @Override
    protected void onProgressUpdate(Integer... progress) {
        //當doInBackground中呼叫publishProgress時回撥,在主執行緒中執行 

        pb_progress.setProgress(progress[0]);
    }

    @Override
    protected void onPostExecute(Long result) {
        //在非同步任務執行之後回撥，在主執行緒中執行
        Toast.makeText(MainActivity.this, "下載完成，結果是" + result, Toast.LENGTH_SHORT).show();
    }

    @Override
    protected void onCancelled() {
        //在非同步任務被取消時回撥
        super.onCancelled();
    }
}

一、引數分析

通過原始碼，可以看到AsyncTask是個抽象的泛型類

public abstract class AsyncTask<Params, Progress, Result>

Params：表示後臺任務執行時的引數型別（對應例子中的URL），該引數會傳給AysncTask的doInBackground()方法
Progress：表示後臺任務的執行進度的引數型別（對應例子中的Integer），該引數會作為onProgressUpdate()方法的引數
Result：表示後臺任務的返回結果的引數型別（對應例子中的Long），該引數會作為onPostExecute()方法的引數

注意這三個引數都是代表的型別，如果AsyncTask確實不需要傳遞具體的引數，那麼這三個泛型引數可以用Void來代替

二、方法分析

常用的AsyncTask繼承的方法有

onPreExecute()：非同步任務開啟之前回調，在主執行緒中執行
doInBackground()：執行非同步任務，線上程池中執行
onProgressUpdate()：當doInBackground中呼叫publishProgress時回撥，在主執行緒中執行
onPostExecute()：在非同步任務執行之後回撥，在主執行緒中執行
onCancelled()：在非同步任務被取消時回撥

三、開啟非同步

在主Activity中通過點選按鈕執行我們建立的非同步任務，然後通過execute()方法執行非同步任務

bt_down.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        try {
            URL url = new URL("http://blog.csdn.net/");
            new DownloadFilesTask().execute(url);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }
});

四、效果圖

AsyncTask原始碼分析

原始碼分析是基於API24的原始碼，我將會按照下面AsyncTask執行的過程來分析

一、主分支

首先，execute()方法，開啟非同步任務
接著，onPreExecute()方法，非同步任務開啟前
接著，doInBackground()方法，非同步任務正在執行
最後，onPostExecute()方法，非同步任務完成

二、次分支

onProgressUpdate()方法，非同步任務更新UI
onCancelled()方法，非同步任務取消

主分支部分

程式碼開始的地方，是在建立AsyncTask類之後執行的execute()方法

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

execute()方法會呼叫executeOnExecutor()方法

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

AsyncTask定義了一個mStatus變數，表示非同步任務的執行狀態，分別是PENDING、RUNNING、FINISHED，當只有PENDING狀態時，AsyncTask才會執行，這樣也就保證了AsyncTask只會被執行一次

繼續往下執行，mStatus會被標記為RUNNING，接著執行，onPreExecute()，將引數賦值給mWorker，然後還有execute(mFuture)

這裡的mWorker和mFuture究竟是什麼，我們往下追蹤，來到AsyncTask的建構函式中，可以找到這兩個的初始化

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

一、分析mWorker

mWorker是一個WorkerRunnable物件，跟蹤WorkerRunnable

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

實際上，WorkerRunnable是AsyncTask的一個抽象內部類，實現了Callable介面

二、分析mFuture

mFuture是一個FutureTask物件，跟蹤FutureTask

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

實際上，FutureTask是java.util.concurrent包下的一個類，引數是個callable，並且將它賦值給FutureTask類中的callable

三、回過頭來看

回到我們AsyncTask初始化mFuture，這裡的引數是mWorker也就不奇怪了，因為mWorker就是一個callable，我們在上面賦值給FutureTask類中的callable就是這個mWorker

mFuture = new FutureTask<Result>(mWorker)

而關於mWorker和mFuture的初始化早在我們Activity中初始化好了，因為建構函式是跟AsyncTask類的建立而執行的

new DownloadFilesTask()

知道了mWorker和mFuture是什麼後，我們回到原來的executeOnExecutor()方法，在這裡將mWorker的引數傳過去後，就開始用執行緒池execute這個mFuture

mWorker.mParams = params;
exec.execute(mFuture);

一、分析exec

exec是通過executeOnExecutor()引數傳進來的

public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params)

也就是我們execute()方法傳過來的

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

這裡可以看到exec就是這個sDefaultExecutor

二、分析sDefaultExecutor

我們跟蹤這個sDefaultExecutor，擷取有關它的程式碼

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

從SerialExecutor可以發現，exec.execute(mFuture)就是在呼叫SerialExecutor類的execute(final Runnable r)方法，這裡的引數r就是mFuture

繼續往下走，SerialExecutor的execute()方法會將r封裝成Runnable，並新增到mTasks任務佇列中

繼續往下走，如果這時候沒有正在活動的AsyncTask任務，那麼就會呼叫SerialExecutor的scheduleNext()方法，來執行下一個AsyncTask任務

if (mActive == null) {
    scheduleNext();
}

繼續往下走，通過mTasks.poll()取出，將封裝在mTask的Runnable交給mActive，最後真正執行的這個mActive的是THREAD_POOL_EXECUTOR，即執行的這個mActive，也就是包裝在Runnable裡面的mFuture

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

mFuture被執行了，也就會執行它的run()方法

public void run() {
    try {
        r.run();
    } finally {
        scheduleNext();
    }
}

我們跟蹤到mFuture的run()方法中，切換到FutureTask類

public void run() {
    if (state != NEW ||
        !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                result = c.call();
                ran = true;
            } catch (Throwable ex) {
                result = null;
                ran = false;
                setException(ex);
            }
            if (ran)
                set(result);
        }
    } finally {
        // runner must be non-null until state is settled to
        // prevent concurrent calls to run()
        runner = null;
        // state must be re-read after nulling runner to prevent
        // leaked interrupts
        int s = state;
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

這一段程式碼其實就是將之前在mFutrue建立物件時候傳進來的mWorker交給c

Callable<V> c = callable;

然後再呼叫c的call()方法，也就是mWorker的call()方法

result = c.call();

程式碼又重新的定位到了mWorker類的call()方法

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

可以發現，這裡就呼叫了我們的doInBackground()方法，最後還返回postResult()，我們跟蹤這個postResult()方法

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

觀察程式碼，首先是getHandler()，它是一個單例，返回sHandler

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

也就是說postResult方法會通過sHandler傳送一個MESSAGE_POST_RESULT的訊息，這個時候我們追蹤到sHandler

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

可以發現，sHandler收到MESSAGE_POST_PROGRESS訊息後會呼叫result.mTask.finish(result.mData[0])，那麼我們還必須知道result是個什麼東西

AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;

result是AsyncTask的內部類，實際上就是個實體類，用來儲存變數的

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

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

result.mTask也就是AsyncTask，最後呼叫result.mTask.finish(result.mData[0])，即AsyncTask的finish()方法，我們跟蹤到finish()方法

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

這裡判斷AsyncTask是否已經取消，如果不取消就執行我們的onPostExecute()，最後將狀態設定為FINISHED，整一個AsyncTask的方法都執行完了，我們只需要繼承AsyncTask實現其中的方法就可以按分析的順序往下執行了

次分支部分

在AsyncTask中的finish()方法，我們可以看到onCancelled()方法跟onPostExecute()一起的，只要isCancelled()的值為true，就執行onCancelled()方法

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

我們程式碼跟蹤isCancelled()方法

public final boolean isCancelled() {
    return mCancelled.get();
}

發現是在mCancelled中獲取的，那我們就必須知道這個mCancelled是什麼，程式碼跟蹤到mCancelled

private final AtomicBoolean mCancelled = new AtomicBoolean();

mCancelled實際上就是個Boolean物件，那我們搜尋它是在哪個時候設定的

public final boolean cancel(boolean mayInterruptIfRunning) {
    mCancelled.set(true);
    return mFuture.cancel(mayInterruptIfRunning);
}

可以發現，只要我們在AsyncTask類中呼叫這個方法即可停止非同步任務

而onProgressUpdate()方法，是在sHandler中執行，sHandler收到MESSAGE_POST_PROGRESS訊息後，執行，我們搜尋MESSAGE_POST_PROGRESS在什麼時候傳送的

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

可以發現，只要我們在AsyncTask類中呼叫publishProgress()方法即可執行onProgressUpdate()方法

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

結語

AsyncTask使用與原始碼分析就到這裡結束了，如果是初學者，這可能會是比較難的分析，如果是想往中高階進階的朋友，瞭解AsyncTask的原理是必須的。隨著時代的發展，流行的非同步框架RxJava的出現已經可以說是替代了這個AsyncTask，為了跟進時代的發展，我也得抽取時間來學習了，廢話就不說了，還是節省點時間來學習吧

Android進階——多執行緒系列之非同步任務AsyncTask的使用與原始碼分析

AsyncTask是什麼

AsyncTask的使用

AsyncTask原始碼分析

主分支部分

次分支部分

結語

Android進階——多執行緒系列之非同步任務AsyncTask的使用與原始碼分析

Android進階——多執行緒系列之wait、notify、sleep、join、yield、synchronized關鍵字、ReentrantLock鎖

Java 進階——多執行緒優化之執行緒池 ThreadPoolExecutor的核心容器阻塞佇列詳解（一）

Android進階——多執行緒和非同步任務小結

[進階]-多執行緒、多程序、非同步IO實用例子

java多執行緒系列之模式|第一篇-Guarded Suspension pattern

java多執行緒系列之模式|第三篇: Producer-Consumer pattern

多執行緒系列之 java多執行緒的個人理解(二)

【多執行緒】程式猿進階多執行緒（四）—— 執行緒同步

多執行緒系列之——事件核心物件

C# 多執行緒五之Task(任務)

C# 多執行緒六之Task(任務)二

C# 多執行緒六之Task(任務)三之任務工廠 C# 多執行緒六之Task(任務)二

多執行緒高併發程式設計(8) -- Fork/Join原始碼分析

Java多執行緒系列--“JUC原子類”03之 AtomicLong原子類

Java多執行緒系列---“JUC原子類”04之 AtomicLongArray原子類

Java多執行緒系列---“JUC原子類”05之 AtomicReference原子類

Java多執行緒系列---“JUC原子類”06之 AtomicLongFieldUpdater原子類

Java多執行緒系列---“JUC原子類”01之原子類的實現（CAS演算法）

Java多執行緒系列---“JUC原子類”02之框架

Android進階——多執行緒系列之非同步任務AsyncTask的使用與原始碼分析

AsyncTask是什麼

AsyncTask的使用

AsyncTask原始碼分析

主分支部分

次分支部分

結語

相關推薦