android線程切換

Ⅰ Android Handler使用

在日常開發中，都避免不了進行網路請求，並更新View，由於Android中主線程不可以進行耗時操作，所以我們的網路請求只能放在子線程中，又由於在子線程中不能更新UI，所以我們就需要使用Handler切換到主線程並更新UI。

在介紹Handler使用之前，我們先了解以下兩個問題。

1、為什麼主線程不能進行耗時操作？
因為如果在主線程進行耗時操作，容易出現ANR，Application Not Responding，即應用無響應，當在一定的時間內，app無法響應時就會出現ANR，並彈出一個 對話框提示應用無響應，所以我們應該避免在主線程中進行耗時操作，當我們應用出現ANR時，會在
/data/anr/目錄中生成traces.txt，我們可以通過這個文件查找錯誤信息。

2、為什麼子線程中不能更新UI？
這是因為在子線程中更新UI不是線程安全的，在Android源碼ViewRootImpl的checkThread方法中也對UI做了驗證。

基於這兩個問題，我們可以使用Handler來解決，接下來介紹Handler的基本使用。

首先創建Handler

接下來發送消息。

這個時候在handlerMessage方法中即可收到消息，獲取Message中的數據，並更新UI了。是不是很簡單。

Ⅱ Android多線程的四種方式：Handler、AsyncTask、ThreadPoolExector、IntentService

     非同步通信機制，將工作線程中需更新UI的操作信息 傳遞到 UI主線程，從而實現 工作線程對UI的更新處理，最終實現非同步消息的處理。Handler不僅僅能將子線程的數據傳遞給主線程，它能實現任意兩個線程的數據傳遞。

（1）Message

    Message 可以在線程之間傳遞消息。可以在它的內部攜帶少量數據，用於在不同線程之間進行數據交換。除了 what 欄位，還可以使用 arg1 和 arg2 來攜帶整型數據，使用 obj 來攜帶 Object 數據。

（2） Handler

    Handler 作為處理中心，用於發送（sendMessage 系列方法）與處理消息（handleMessage 方法）。

（3） MessageQueue

    MessageQueue 用於存放所有通過 Handler 發送的消息。這部分消息會一直存放在消息隊列中，直到被處理。每個線程中只會有一個 MessageQueue 對象

（4） Looper

    Looper 用於管理 MessageQueue 隊列，Looper對象通過loop()方法開啟了一個死循環——for (;;)｛｝，不斷地從looper內的MessageQueue中取出Message，並傳遞到 Handler 的 handleMessage() 方法中。每個線程中只會有一個 Looper 對象。

    AsyncTask 是一種輕量級的任務非同步類，可以在後檯子線程執行任務，且將執行進度及執行結果傳遞給 UI 線程。

（1）onPreExecute()

    在 UI 線程上工作，在任務執行 doInBackground() 之前調用。此步驟通常用於設置任務，例如在用戶界面中顯示進度條。

（2）doInBackground(Params... params)

    在子線程中工作，在 onPreExecute() 方法結束後執行，這一步被用於在後台執行長時間的任務，Params 參數通過 execute(Params) 方法被傳遞到此方法中。任務執行結束後，將結果傳遞給 onPostExecute(Result) 方法，同時我們可以通過 publishProgress(Progress) 方法，將執行進度發送給 onProgressUpdate(Progress) 方法。

（3）onProgressUpdate(Progress... values)

    在 UI 線程上工作，會在 doInBackground() 中調用 publishProgress(Progress) 方法後執行，此方法用於在後台計算仍在執行時(也就是 doInBackgound() 還在執行時)將計算執行進度通過 UI 顯示出來。例如，可以通過動畫進度條或顯示文本欄位中的日誌，從而方便用戶知道後台任務執行的進度。

（4）onPostExecute(Result result)

    在 UI 線程上工作，在任務執行完畢（即 doInBackground(Result) 執行完畢）並將執行結果傳過來的時候工作。

使用規則：

（1）AsyncTask 是個抽象類，所以要創建它的子類實現抽象方法

（1）AsyncTask 類必須是在 UI 線程中被載入，但在Android 4.1（API 16）開始，就能被自動載入完成。

（2）AsyncTask 類的實例對象必須在 UI 線程中被創建。

（3）execute() 方法必須是在 UI 線程中被調用。

（4）不要手動調用方法 onPreExecute()、onPostExecute()、doInBackground()、onProgressUpdate()

（5）任務只能執行一次(如果嘗試第二次執行，將拋出異常)。即一個AsyncTask對象只能調用一次execute()方法。

原理：

          其源碼中原理還是 Thread 與 Handler 的實現，其包含 兩個線程池，一個 Handler，如下所示：

名稱類型作用

SERIAL_EXECUTOR線程池分發任務，串列分發，一次只分發一個任務

THREAD_POOL_EXECUTOR線程池執行任務，並行執行，執行的任務由 SERIAL_EXECUTOR 分發

InternalHandlerHandler負責子線程與主線程的溝通，通知主線程做 UI 工作

    一方面減少了每個並行任務獨自建立線程的開銷，另一方面可以管理多個並發線程的公共資源，從而提高了多線程的效率。所以ThreadPoolExecutor比較適合一組任務的執行。Executors利用工廠模式對ThreadPoolExecutor進行了封裝。

Executors提供了四種創建ExecutorService的方法，他們的使用場景如下：

1. Executors.newFixedThreadPool()

    創建一個定長的線程池，每提交一個任務就創建一個線程，直到達到池的最大長度，這時線程池會保持長度不再變化。

當線程處於空閑狀態時，它們並不會被回收，除非線程池被關閉。當所有的線程都處於活動狀態時，新任務都會處於等待狀態，直到有線程空閑出來。

只有核心線程並且不會被回收，能夠更加快速的響應外界的請求。

2. Executors.newCachedThreadPool()

    創建一個可緩存的線程池，如果當前線程池的長度超過了處理的需要時，它可以靈活的回收空閑的線程，當需要增加時，它可以靈活的添加新的線程，而不會對池的長度作任何限制

    線程數量不定的線程池，只有非核心線程，最大線程數為 Integer.MAX_VALUE。當線程池中的線程都處於活動狀態時，線程池會創建新的線程來處理新任務，否則利用空閑的線程來處理新任務。線程池中的空閑線程具有超時機制，為 60s。

    任務隊列相當於一個空集合，導致任何任務都會立即被執行，適合執行大量耗時較少的任務。當整個線程池都處於限制狀態時，線程池中的線程都會超時而被停止。

3. Executors.newScheledThreadPool()

    創建一個定長的線程池，而且支持定時的以及周期性的任務執行，類似於Timer。

    非核心線程數沒有限制，並且非核心線程閑置的時候立即回收，主要用於執行定時任務和具有固定周期的重復任務。

4. Executors.newSingleThreadExecutor()

    創建一個單線程化的executor，它只創建唯一的worker線程來執行任務

    只有一個核心線程，保證所有的任務都在一個線程中順序執行，意義在於不需要處理線程同步的問題。

    一般用於執行後台耗時任務，當任務執行完成會自動停止；同時由於它是一個服務，優先順序要遠遠高於線程，更不容易被系統殺死，因此比較適合執行一些高優先順序的後台任務。

使用步驟：創建IntentService的子類，重寫onHandleIntent方法，在onHandleIntent中執行耗時任務

    原理：在源碼實現上，IntentService封裝了HandlerThread和Handler。onHandleIntent方法結束後會調用IntentService的stopSelf(int startId)方法嘗試停止服務。

    IntentService的內部是通過消息的方式請求HandlerThread執行任務，HandlerThread內部又是一種使用Handler的Thread，這就意味著IntentService和Looper一樣是順序執行後台任務的

（HandlerThread：封裝了Handler + ThreadHandlerThread適合在有需要一個工作線程（非UI線程）+任務的等待隊列的形式，優點是不會有堵塞，減少了對性能的消耗，缺點是不能同時進行多個任務的處理，需要等待進行處理。處理效率低，可以當成一個輕量級的線程池來用）

Ⅲ Android 中的「子線程」解析

Android 中線程可分為 主線程 和 子線程 兩類，其中主線程也就是 UI線程 ，它的主要這作用就是運行四大組件、處理界面交互。子線程則主要是處理耗時任務，也是我們要重點分析的。

首先 Java 中的各種線程在 Android 里是通用的，Android 特有的線程形態也是基於 Java 的實現的，所以有必要先簡單的了解下 Java 中的線程，本文主要包括以下內容：

在 Java 中要創建子線程可以直接繼承 Thread 類，重寫 run() 方法：

或者實現 Runnable 介面，然後用Thread執行Runnable，這種方式比較常用：

簡單的總結下：

Callable 和 Runnable 類似，都可以用來處理具體的耗時任務邏輯的，但是但具體的差別在哪裡呢？看一個小例子：

定義 MyCallable 實現了 Callable 介面，和之前 Runnable 的 run() 方法對比下， call() 方法是有返回值的哦，泛型就是返回值的類型：

一般會通過線程池來執行 Callable （線程池相關內容後邊會講到），執行結果就是一個 Future 對象：

可以看到，通過線程池執行 MyCallable 對象返回了一個 Future 對象，取出執行結果。

Future 是一個介面，從其內部的方法可以看出它提供了取消任務（有坑！！！）、判斷任務是否完成、獲取任務結果的功能：

Future 介面有一個 FutureTask 實現類，同時 FutureTask 也實現了 Runnable 介面，並提供了兩個構造函數：

用 FutureTask 一個參數的構造函數來改造下上邊的例子：

FutureTask 內部有一個 done() 方法，代表 Callable 中的任務已經結束，可以用來獲取執行結果：

所以 Future + Callable 的組合可以更方便的獲取子線程任務的執行結果，更好的控制任務的執行，主要的用法先說這么多了，其實 AsyncTask 內部也是類似的實現！

注意， Future 並不能取消掉運行中的任務，這點在後邊的 AsyncTask 解析中有提到。

Java 中線程池的具體的實現類是 ThreadPoolExecutor ，繼承了 Executor 介面，這些線程池在 Android 中也是通用的。使用線程池的好處：

常用的構造函數如下：

一個常規線程池可以按照如下方式來實現：

執行任務：

基於 ThreadPoolExecutor ，系統擴展了幾類具有新特性的線程池：

線程池可以通過 execute() 、 submit() 方法開始執行任務，主要差別從方法的聲明就可以看出，由於 submit() 有返回值，可以方便得到任務的執行結果：

要關閉線程池可以使用如下方法：

IntentService 是 Android 中一種特殊的 Service，可用於執行後台耗時任務，任務結束時會自動停止，由於屬於系統的四大組件之一，相比一般線程具有較高的優先順序，不容易被殺死。用法和普通 Service 基本一致，只需要在 onHandleIntent() 中處理耗時任務即可：

至於 HandlerThread，它是 IntentService 內部實現的重要部分，細節內容會在 IntentService 源碼中說到。

IntentService 首次創建被啟動的時候其生命周期方法 onCreate() 會先被調用，所以我們從這個方法開始分析：

這里出現了 HandlerThread 和 ServiceHandler 兩個類，先搞明白它們的作用，以便後續的分析。

首先看 HandlerThread 的核心實現：

首先它繼承了 Thread 類，可以當做子線程來使用，並在 run() 方法中創建了一個消息循環系統、開啟消息循環。

ServiceHandler 是 IntentService 的內部類，繼承了 Handler，具體內容後續分析：

現在回過頭來看 onCreate() 方法主要是一些初始化的操作， 首先創建了一個 thread 對象，並啟動線程，然後用其內部的 Looper 對象 創建一個 mServiceHandler 對象，將子線程的 Looper 和 ServiceHandler 建立了綁定關系，這樣就可以使用 mServiceHandler 將消息發送到子線程去處理了。

生命周期方法 onStartCommand() 方法會在 IntentService 每次被啟動時調用，一般會這里處理啟動 IntentService 傳遞 Intent 解析攜帶的數據：

又調用了 start() 方法：

就是用 mServiceHandler 發送了一條包含 startId 和 intent 的消息，消息的發送還是在主線程進行的，接下來消息的接收、處理就是在子線程進行的：

當接收到消息時，通過 onHandleIntent() 方法在子線程處理 intent 對象， onHandleIntent() 方法執行結束後，通過 stopSelf(msg.arg1) 等待所有消息處理完畢後終止服務。

為什麼消息的處理是在子線程呢？這里涉及到 Handler 的內部消息機制，簡單的說，因為 ServiceHandler 使用的 Looper 對象就是在 HandlerThread 這個子線程類里創建的，並通過 Looper.loop() 開啟消息循環，不斷從消息隊列（單鏈表）中取出消息，並執行，截取 loop() 的部分源碼：

dispatchMessage() 方法間接會調用 handleMessage() 方法，所以最終 onHandleIntent() 就在子線程中劃線執行了，即 HandlerThread 的 run() 方法。

這就是 IntentService 實現的核心，通過 HandlerThread + Hanlder 把啟動 IntentService 的 Intent 從主線程切換到子線程，實現讓 Service 可以處理耗時任務的功能！

AsyncTask 是 Android 中輕量級的非同步任務抽象類，它的內部主要由線程池以及 Handler 實現，在線程池中執行耗時任務並把結果通過 Handler 機制中轉到主線程以實現UI操作。典型的用法如下：

從 Android3.0 開始，AsyncTask 默認是串列執行的：

如果需要並行執行可以這么做：

AsyncTask 的源碼不多，還是比較容易理解的。根據上邊的用法，可以從 execute() 方法開始我們的分析：

看到 @MainThread 註解了嗎？所以 execute() 方法需要在主線程執行哦！

進而又調用了 executeOnExecutor() ：

可以看到，當任務正在執行或者已經完成，如果又被執行會拋出異常！回調方法 onPreExecute() 最先被執行了。

傳入的 sDefaultExecutor 參數，是一個自定義的串列線程池對象，所有任務在該線程池中排隊執行：

可以看到 SerialExecutor 線程池僅用於任務的排隊， THREAD_POOL_EXECUTOR 線程池才是用於執行真正的任務，就是我們線程池部分講到的 ThreadPoolExecutor ：

再回到 executeOnExecutor() 方法中，那麼 exec.execute(mFuture) 就是觸發線程池開始執行任務的操作了。

那 executeOnExecutor() 方法中的 mWorker 是什麼？ mFuture 是什麼？答案在 AsyncTask 的構造函數中：

原來 mWorker 是一個 Callable 對象， mFuture 是一個 FutureTask 對象，繼承了 Runnable 介面。所以 mWorker 的 call() 方法會在 mFuture 的 run() 方法中執行，所以 mWorker 的 call() 方法在線程池得到執行！

同時 doInBackground() 方法就在 call() 中方法，所以我們自定義的耗時任務邏輯得到執行，不就是我們第二部分講的那一套嗎！

doInBackground() 的返回值會傳遞給 postResult() 方法：

就是通過 Handler 將最終的耗時任務結果從子線程發送到主線程，具體的過程是這樣的， getHandler() 得到的就是 AsyncTask 構造函數中初始化的 mHandler ， mHander 又是通過 getMainHandler() 賦值的：

可以在看到 sHandler 是一個 InternalHandler 類對象：

所以 getHandler() 就是在得到在主線程創建的 InternalHandler 對象，所以
就可以完成耗時任務結果從子線程到主線程的切換，進而可以進行相關UI操作了。
當消息是 MESSAGE_POST_RESULT 時，代表任務執行完成， finish() 方法被調用：

如果任務沒有被取消的話執行 onPostExecute() ，否則執行 onCancelled() 。

如果消息是 MESSAGE_POST_PROGRESS ， onProgressUpdate() 方法被執行，根據之前的用法可以 onProgressUpdate() 的執行需要我們手動調用 publishProgress() 方法，就是通過 Handler 來發送進度數據：

進行中的任務如何取消呢？AsyncTask 提供了一個 cancel(boolean mayInterruptIfRunning) ，參數代表是否中斷正在執行的線程任務，但是呢並不靠譜， cancel() 的方法注釋中有這么一段：

大致意思就是調用 cancel() 方法後， onCancelled(Object) 回調方法會在 doInBackground() 之後被執行而 onPostExecute() 將不會被執行，同時你應該 doInBackground() 回調方法中通過 isCancelled() 來檢查任務是否已取消，進而去終止任務的執行！

所以只能自己動手了：

AsyncTask 整體的實現流程就這些了，源碼是最好的老師，自己跟著源碼走一遍有些問題可能就豁然開朗了！

Ⅳ Android中線程與線程，進程與進程之間如何通信

使用handler發送message,消息隊列排隊

進程是一個具有獨立功能的程序關於某個數據集合的一次運行活動。它可以申請和擁有系統資源，是一個動態的概念，是一個活動的實體。它不只是程序的代碼，還包括當前的活動，通過程序計數器的值和處理寄存器的內容來表示。
進程是一個「執行中的程序」。程序是一個沒有生命的實體，只有處理器賦予程序生命時，它才能成為一個活動的實體，我們稱其為進程。
通常在一個進程中可以包含若干個線程，它們可以利用進程所擁有的資源。在引入線程的操作系統中，通常都是把進程作為分配資源的基本單位，而把線程作為獨立運行和獨立調度的基本單位。由於線程比進程更小，基本上不擁有系統資源，故對它的調度所付出的開銷就會小得多，能更高效的提高系統內多個程序間並發執行的程度。
線程和進程的區別在於，子進程和父進程有不同的代碼和數據空間，而多個線程則共享數據空間，每個線程有自己的執行堆棧和程序計數器為其執行上下文。多線程主要是為了節約CPU時間，發揮利用，根據具體情況而定。線程的運行中需要使用計算機的內存資源和CPU。

Ⅳ Android的handler機制的原理

Android的handler機制的原理分為非同步通信准備，消息發送，消息循環，消息處理。

1、非同步通信准備

在主線程中創建處理器對象(Looper)、消息隊列對象(Message Queue)和Handler對象。

2、消息入隊

工作線程通過Handler發送消息(Message) 到消息隊列(Message Queue)中。

3、消息循環

消息出隊: Looper循環取出消息隊列(Message Queue) 中的的消息(Message)。

消息分發: Looper將取出的消息 (Message) 發送給創建該消息的處理者(Handler)。

4、消息處理

處理者(Handler) 接收處理器(Looper) 發送過來的消息(Message)，根據消息(Message) 進行U操作。

handler的作用

handler是android線程之間的消息機制，主要的作用是將一個任務切換到指定的線程中去執行，（准確的說是切換到構成handler的looper所在的線程中去出處理）android系統中的一個例子就是主線程中的所有操作都是通過主線程中的handler去處理的。

Handler的運行需要底層的 messagequeue和 looper做支撐。

Ⅵ android 大量多線程怎麼優化

在程序開發的實踐當中，為了讓程序表現得更加流暢，我們肯定會需要使用到多線程來提升程序的並發執行性能。但是編寫多線程並發的代碼一直以來都是一個相對棘手的問題，所以想要獲得更佳的程序性能，我們非常有必要掌握多線程並發編程的基礎技能。
眾所周知，Android 程序的大多數代碼操作都必須執行在主線程，例如系統事件(例如設備屏幕發生旋轉)，輸入事件(例如用戶點擊滑動等)，程序回調服務，UI 繪制以及鬧鍾事件等等。那麼我們在上述事件或者方法中插入的代碼也將執行在主線程。

一旦我們在主線程裡面添加了操作復雜的代碼，這些代碼就很可能阻礙主線程去響應點擊/滑動事件，阻礙主線程的 UI 繪制等等。我們知道，為了讓屏幕的刷新幀率達到 60fps，我們需要確保 16ms 內完成單次刷新的操作。一旦我們在主線程裡面執行的任務過於繁重就可能導致接收到刷新信號的時候因為資源被佔用而無法完成這次刷新操作，這樣就會產生掉幀的現象，刷新幀率自然也就跟著下降了(一旦刷新幀率降到 20fps 左右，用戶就可以明顯感知到卡頓不流暢了)。

為了避免上面提到的掉幀問題，我們需要使用多線程的技術方案，把那些操作復雜的任務移動到其他線程當中執行，這樣就不容易阻塞主線程的操作，也就減小了出現掉幀的可能性。

那麼問題來了，為主線程減輕負的多線程方案有哪些呢？這些方案分別適合在什麼場景下使用？Android 系統為我們提供了若干組工具類來幫助解決這個問題。
AsyncTask: 為 UI 線程與工作線程之間進行快速的切換提供一種簡單便捷的機制。適用於當下立即需要啟動，但是非同步執行的生命周期短暫的使用場景。
HandlerThread: 為某些回調方法或者等待某些任務的執行設置一個專屬的線程，並提供線程任務的調度機制。
ThreadPool: 把任務分解成不同的單元，分發到各個不同的線程上，進行同時並發處理。
IntentService: 適合於執行由 UI 觸發的後台 Service 任務，並可以把後台任務執行的情況通過一定的機制反饋給 UI。
了解這些系統提供的多線程工具類分別適合在什麼場景下，可以幫助我們選擇合適的解決方案，避免出現不可預期的麻煩。雖然使用多線程可以提高程序的並發量，但是我們需要特別注意因為引入多線程而可能伴隨而來的內存問題。舉個例子，在 Activity 內部定義的一個 AsyncTask，它屬於一個內部類，該類本身和外面的 Activity 是有引用關系的，如果 Activity 要銷毀的時候，AsyncTask 還仍然在運行，這會導致 Activity 沒有辦法完全釋放，從而引發內存泄漏。所以說，多線程是提升程序性能的有效手段之一，但是使用多線程卻需要十分謹慎小心，如果不了解背後的執行機制以及使用的注意事項，很可能引起嚴重的問題。

Ⅶ Android 進程和線程的區別

·有一段程序供其執行
·擁有專用的系統堆棧空間
·在內存中有對應的進程式控制制塊
·擁有獨立的用戶存儲空間
·進程之間不能進行自由的信息交互（別問我，問就是Android規定的）

·每個進程必須包含一個線程
·進程間的切換開銷比較大，線程創建和終止比進程快，進程間無法進行自由的資源交換，同進程內的線程可以自由交換

我們可以將Android系統比做一個大公司，進程相當於某個部門的經理，他有自己要做到項目（有一段程序供其執行，在內存中有對應的進程式控制制塊），擁有自己部門的辦公場地（擁有獨立的用戶存儲空間）。
線程就相當於每個部門的員工，員工得依賴於經理提供的工作環境才能夠進行工作（線程必須依賴於進程），而經理手下必須得有一個員工（要不然分配的工作交給誰來做），我們都知道在一個大公司下每個部門和每個部門溝通是比較困難的，但是一個部門之間的員工溝通相對容易許多（同進程下的線程共享資源）。

參考： https://blog.csdn.net/u012221046/article/details/78010365

Ⅷ android 中 任務，進程和線程的區別

android 中 任務，進程和線程的區別

• 進程：是一個具有獨立功能的程序關於某個數據集合的一次運行活動。進程是系統進行資源分配和調度的一個獨立單位。可以申請和擁有系統資源，是一個動態的概念，是一個活動的實體，是一個「執行中的程序」。不只是程序的代碼，還包括當前的活動。

• 線程：線程是進程的一個實體,是CPU調度和分

• 派的基本單位,它是比進程更小的能獨立運行的基本單位。線程比進程更小，基本上不擁有系統資源，故對它的調度所用資源小，能更高效的提高系統內多個程序間並發執行的

• 程度。

• 線程和進程的區別：

• 1、子進程和父進程有不同的代碼和數據空間，而多個線程則共享數據空間，每個線程有自己的執行堆棧和程序計數器為其執行上下文。

• 2、進程間相互獨立，同一進程的各線程間共享。某進程內的線程在其它進程不可見。

• 3、進程間通信IPC，線程間可以直接讀寫進程數據段（如全局變數）來進行通信——需要進程同步和互斥手段的輔助，以保證數據的一致性。

• 4、線程上下文切換比進程上下文切換要快得多。

• 小剛SEO為你解答
  

Ⅸ android：線程跳轉到另一個activity時，新activity不能創建線程

這個問題只需要了解Activity的啟動模擬即可。
Activity啟動模式有4種，分別為standard、singleTop、singleTask、singleInstance。

1.standard 默認模式，可以不用寫配置。在這個模式下，都會默認創建一個新的實例。因此，在這種模式下，可以有多個相同的實例，也允許多個相同Activity疊加。

2.singleTop 可以有多個實例，但是不允許多個相同Activity疊加。即，如果Activity在棧頂的時候，啟動相同的Activity，不會創建新的實例，而會調用其onNewIntent方法。
3.singleTask 只有一個實例。在同一個應用程序中啟動他的時候，若Activity不存在，則會在當前task創建一個新的實例，若存在，則會把task中在其之上的其它Activity destory掉並調用它的onNewIntent方法。
3.singleInstance只有一個實例，並且這個實例獨立運行在一個task中，這個task只有這個實例，不允許有別的Activity存在。

Ⅹ Android中的線程狀態 - AsyncTask詳解

在操作系統中，線程是操作系統調度的最小單元，同時線程又是一種受限的系統資源，即線程不可能無限制地產生，並且 線程的創建和銷毀都會有相應的開銷。 當系統中存在大量的線程時，系統會通過會時間片輪轉的方式調度每個線程，因此線程不可能做到絕對的並行。

如果在一個進程中頻繁地創建和銷毀線程，顯然不是高效的做法。正確的做法是採用線程池，一個線程池中會緩存一定數量的線程，通過線程池就可以避免因為頻繁創建和銷毀線程所帶來的系統開銷。

AsyncTask是一個抽象類，它是由Android封裝的一個輕量級非同步類（輕量體現在使用方便、代碼簡潔），它可以在線程池中執行後台任務，然後把執行的進度和最終結果傳遞給主線程並在主線程中更新UI。

AsyncTask的內部封裝了 兩個線程池 (SerialExecutor和THREAD_POOL_EXECUTOR)和 一個Handler (InternalHandler)。

其中 SerialExecutor線程池用於任務的排隊，讓需要執行的多個耗時任務，按順序排列 ， THREAD_POOL_EXECUTOR線程池才真正地執行任務 ， InternalHandler用於從工作線程切換到主線程 。

1.AsyncTask的泛型參數

AsyncTask是一個抽象泛型類。

其中，三個泛型類型參數的含義如下：

Params： 開始非同步任務執行時傳入的參數類型；

Progress： 非同步任務執行過程中，返回下載進度值的類型；

Result： 非同步任務執行完成後，返回的結果類型；

如果AsyncTask確定不需要傳遞具體參數，那麼這三個泛型參數可以用Void來代替。

有了這三個參數類型之後，也就控制了這個AsyncTask子類各個階段的返回類型，如果有不同業務，我們就需要再另寫一個AsyncTask的子類進行處理。

2.AsyncTask的核心方法

onPreExecute()

這個方法會在 後台任務開始執行之間調用，在主線程執行。 用於進行一些界面上的初始化操作，比如顯示一個進度條對話框等。

doInBackground(Params...)

這個方法中的所有代碼都會 在子線程中運行，我們應該在這里去處理所有的耗時任務。

任務一旦完成就可以通過return語句來將任務的執行結果進行返回，如果AsyncTask的第三個泛型參數指定的是Void，就可以不返回任務執行結果。 注意，在這個方法中是不可以進行UI操作的，如果需要更新UI元素，比如說反饋當前任務的執行進度，可以調用publishProgress(Progress...)方法來完成。

onProgressUpdate(Progress...)

當在後台任務中調用了publishProgress(Progress...)方法後，這個方法就很快會被調用，方法中攜帶的參數就是在後台任務中傳遞過來的。 在這個方法中可以對UI進行操作，在主線程中進行，利用參數中的數值就可以對界面元素進行相應的更新。

onPostExecute(Result)

當doInBackground(Params...)執行完畢並通過return語句進行返回時，這個方法就很快會被調用。返回的數據會作為參數傳遞到此方法中， 可以利用返回的數據來進行一些UI操作，在主線程中進行，比如說提醒任務執行的結果，以及關閉掉進度條對話框等。

上面幾個方法的調用順序：

onPreExecute() --> doInBackground() --> publishProgress() --> onProgressUpdate() --> onPostExecute()

如果不需要執行更新進度則為onPreExecute() --> doInBackground() --> onPostExecute(),

除了上面四個方法，AsyncTask還提供了onCancelled()方法， 它同樣在主線程中執行，當非同步任務取消時，onCancelled()會被調用，這個時候onPostExecute()則不會被調用 ，但是要注意的是， AsyncTask中的cancel()方法並不是真正去取消任務，只是設置這個任務為取消狀態，我們需要在doInBackground()判斷終止任務。就好比想要終止一個線程，調用interrupt()方法，只是進行標記為中斷，需要在線程內部進行標記判斷然後中斷線程。

3.AsyncTask的簡單使用

這里我們模擬了一個下載任務，在doInBackground()方法中去執行具體的下載邏輯，在onProgressUpdate()方法中顯示當前的下載進度，在onPostExecute()方法中來提示任務的執行結果。如果想要啟動這個任務，只需要簡單地調用以下代碼即可：

4.使用AsyncTask的注意事項

①非同步任務的實例必須在UI線程中創建，即AsyncTask對象必須在UI線程中創建。

②execute(Params... params)方法必須在UI線程中調用。

③不要手動調用onPreExecute()，doInBackground(Params... params)，onProgressUpdate(Progress... values)，onPostExecute(Result result)這幾個方法。

④不能在doInBackground(Params... params)中更改UI組件的信息。

⑤一個任務實例只能執行一次，如果執行第二次將會拋出異常。

先從初始化一個AsyncTask時，調用的構造函數開始分析。

這段代碼雖然看起來有點長，但實際上並沒有任何具體的邏輯會得到執行，只是初始化了兩個變數，mWorker和mFuture，並在初始化mFuture的時候將mWorker作為參數傳入。mWorker是一個Callable對象，mFuture是一個FutureTask對象，這兩個變數會暫時保存在內存中，稍後才會用到它們。 FutureTask實現了Runnable介面，關於這部分內容可以看這篇文章。

mWorker中的call()方法執行了耗時操作，即result = doInBackground(mParams);,然後把執行得到的結果通過postResult(result);,傳遞給內部的Handler跳轉到主線程中。在這里這是實例化了兩個變數，並沒有開啟執行任務。

那麼mFuture對象是怎麼載入到線程池中，進行執行的呢？

接著如果想要啟動某一個任務，就需要調用該任務的execute()方法，因此現在我們來看一看execute()方法的源碼，如下所示：

調用了executeOnExecutor()方法,具體執行邏輯在這個方法裡面：

可以 看出，先執行了onPreExecute()方法，然後具體執行耗時任務是在exec.execute(mFuture)，把構造函數中實例化的mFuture傳遞進去了。

exec具體是什麼？

從上面可以看出具體是sDefaultExecutor，再追溯看到是SerialExecutor類，具體源碼如下：

終於追溯到了調用了SerialExecutor 類的execute方法。SerialExecutor 是個靜態內部類，是所有實例化的AsyncTask對象公有的，SerialExecutor 內部維持了一個隊列，通過鎖使得該隊列保證AsyncTask中的任務是串列執行的，即多個任務需要一個個加到該隊列中，然後執行完隊列頭部的再執行下一個，以此類推。

在這個方法中，有兩個主要步驟。

①向隊列中加入一個新的任務，即之前實例化後的mFuture對象。

②調用 scheleNext()方法，調用THREAD_POOL_EXECUTOR執行隊列頭部的任務。

由此可見SerialExecutor 類僅僅為了保持任務執行是串列的，實際執行交給了THREAD_POOL_EXECUTOR。

THREAD_POOL_EXECUTOR又是什麼？

實際是個線程池，開啟了一定數量的核心線程和工作線程。然後調用線程池的execute()方法。執行具體的耗時任務，即開頭構造函數中mWorker中call()方法的內容。先執行完doInBackground()方法，又執行postResult()方法，下面看該方法的具體內容：

該方法向Handler對象發送了一個消息，下面具體看AsyncTask中實例化的Hanlder對象的源碼：

在InternalHandler 中，如果收到的消息是MESSAGE_POST_RESULT，即執行完了doInBackground()方法並傳遞結果，那麼就調用finish()方法。

如果任務已經取消了，回調onCancelled()方法，否則回調 onPostExecute()方法。

如果收到的消息是MESSAGE_POST_PROGRESS，回調onProgressUpdate()方法，更新進度。

InternalHandler是一個靜態類，為了能夠將執行環境切換到主線程，因此這個類必須在主線程中進行載入。所以變相要求AsyncTask的類必須在主線程中進行載入。

到此為止，從任務執行的開始到結束都從源碼分析完了。

AsyncTask的串列和並行

從上述源碼分析中分析得到，默認情況下AsyncTask的執行效果是串列的，因為有了SerialExecutor類來維持保證隊列的串列。如果想使用並行執行任務，那麼可以直接跳過SerialExecutor類，使用executeOnExecutor()來執行任務。

四、AsyncTask使用不當的後果

1.）生命周期

AsyncTask不與任何組件綁定生命周期，所以在Activity/或者Fragment中創建執行AsyncTask時，最好在Activity/Fragment的onDestory()調用 cancel(boolean)；

2.)內存泄漏

3.) 結果丟失

屏幕旋轉或Activity在後台被系統殺掉等情況會導致Activity的重新創建，之前運行的AsyncTask（非靜態的內部類）會持有一個之前Activity的引用，這個引用已經無效，這時調用onPostExecute()再去更新界面將不再生效。

自己是從事了七年開發的Android工程師，不少人私下問我，2019年Android進階該怎麼學，方法有沒有？

沒錯，年初我花了一個多月的時間整理出來的學習資料，希望能幫助那些想進階提升Android開發，卻又不知道怎麼進階學習的朋友。【 包括高級UI、性能優化、架構師課程、NDK、Kotlin、混合式開發（ReactNative+Weex）、Flutter等架構技術資料 】，希望能幫助到您面試前的復習且找到一個好的工作，也節省大家在網上搜索資料的時間來學習。