① [android源碼分析] － 非同步通信Handler機制
一、問題：在Android啟動後會在新進程里創建一個主線程，也叫UI線程（ 非線程安全 ）這個線程主要負責監聽屏幕點擊事件與界面繪制。當Application需要進行耗時操作如網路請求等，如直接在主線程進行容易發生ANR錯誤。所以會創建子線程來執行耗時任務，當子線程執行完畢需要通知UI線程並修改界面時，不可以直接在子線程修改UI，怎麼辦？
解決方法：Message Queue機制可以實現子線程與UI線程的通信。
該機制包括Handler、Message Queue、Looper。Handler可以把消息/ Runnable對象 發給Looper，由它把消息放入所屬線程的消息隊列中，然後Looper又會自動把消息隊列里的消息/Runnable對象 廣播 到所屬線程里的Handler，由Handler處理接收到的消息或Runnable對象。
1、Handler
每次創建Handler對象時，它會自動綁定到創建它的線程上。如果是主線程則默認包含一個Message Queue，否則需要自己創建一個消息隊列來存儲。
Handler是多個線程通信的信使。比如在線程A中創建AHandler，給它綁定一個ALooper，同時創建屬於A的消息隊列AMessageQueue。然後在線程B中使用AHandler發送消息給ALooper，ALooper會把消息存入到AMessageQueue，然後再把AMessageQueue廣播給A線程里的AHandler，它接收到消息會進行處理。從而實現通信。
2、Message Queue
在主線程里默認包含了一個消息隊列不需要手動創建。在子線程里，使用Looper.prepare()方法後，會先檢查子線程是否已有一個looper對象，如果有則無法創建，因為每個線程只能擁有一個消息隊列。沒有的話就為子線程創建一個消息隊列。
Handler類包含Looper指針和MessageQueue指針，而Looper里包含實際MessageQueue與當前線程指針。
下面分別就UI線程和worker線程講解handler創建過程：
首先，創建handler時，會自動檢查當前線程是否包含looper對象，如果包含，則將handler內的消息隊列指向looper內部的消息隊列，否則，拋出異常請求執行looper.prepare()方法。
－ 在 UI線程 中，系統自動創建了Looper 對象，所以，直接new一個handler即可使用該機制；
－ 在 worker線程 中，如果直接創建handler會拋出運行時異常－即通過查『線程－value』映射表發現當前線程無looper對象。所以需要先調用Looper.prepare()方法。在prepare方法里，利用ThreadLocal<Looper>對象為當前線程創建一個Looper（利用了一個Values類，即一個Map映射表，專為thread存儲value，此處為當前thread存儲一個looper對象）。然後繼續創建handler， 讓handler內部的消息隊列指向該looper的消息隊列（這個很重要，讓handler指向looper里的消息隊列，即二者共享同一個消息隊列，然後handler向這個消息隊列發送消息，looper從這個消息隊列獲取消息） 。然後looper循環消息隊列即可。當獲取到message消息，會找出message對象里的target，即原始發送handler，從而回調handler的handleMessage() 方法進行處理。
－ handler與looper共享消息隊列 ，所以handler發送消息只要入列，looper直接取消息即可。
－ 線程與looper映射表 ：一個線程最多可以映射一個looper對象。通過查表可知當前線程是否包含looper，如果已經包含則不再創建新looper。
5、基於這樣的機制是怎樣實現線程隔離的，即在線程中通信呢。
核心在於 每一個線程擁有自己的handler、message queue、looper體系 。而 每個線程的Handler是公開 的。B線程可以調用A線程的handler發送消息到A的共享消息隊列去，然後A的looper會自動從共享消息隊列取出消息進行處理。反之一樣。
二、上面是基於子線程中利用主線程提供的Handler發送消息出去，然後主線程的Looper從消息隊列中獲取並處理。那麼還有另外兩種情況：
1、主線程發送消息到子線程中；
採用的方法和前面類似。要在子線程中實例化AHandler並設定處理消息的方法，同時由於子線程沒有消息隊列和Looper的輪詢，所以要加上Looper.prepare(),Looper.loop()分別創建消息隊列和開啟輪詢。然後在主線程中使用該AHandler去發送消息即可。
2、子線程A與子線程B之間的通信。
1、 Handler為什麼能夠實現不同線程的通信？核心點在哪？
不同線程之間，每個線程擁有自己的Handler、消息隊列和Looper。Handler是公共的，線程可以通過使用目標線程的Handler對象來發送消息，這個消息會自動發送到所屬線程的消息隊列中去，線程自帶的Looper對象會不斷循環從裡面取出消息並把消息發送給Handler，回調自身Handler的handlerMessage方法，從而實現了消息的線程間傳遞。
2、 Handler的核心是一種事件激活式（類似傳遞一個中斷）的還是主要是用於傳遞大量數據的？重點在Message的內容，偏向於數據傳輸還是事件傳輸。
目前的理解，它所依賴的是消息隊列，發送的自然是消息，即類似事件中斷。
0、 Android消息處理機制(Handler、Looper、MessageQueue與Message)
1、 Handler、Looper源碼閱讀
2、 Android非同步消息處理機制完全解析，帶你從源碼的角度徹底理解
謝謝！
wingjay
② Android Handler那些事兒，消息屏障IdelHandlerANR
Handler 是Android SDK中用來處理非同步消息的核心類，子線程可以通過handler來通知主線程進行ui更新。
備註：本文源碼截圖 基於Android sdk 28
Handler機制 消息發送主要流程如圖
應用程序啟動後，zygote fork一個應用進程後，和普通java程序一樣，程序會首先執行ActivityThread中的main函數。在main函數中，程序首先會創建Looper對象並綁定到主線程中，然後開啟loop循環。（ps:主線程loop循環不能退出）
在prepareMainLooper方法中，最終會創建Looper，MessageQueue對象 以及創建native層MessageQueue對象。
使用Handler.sendMessageXXX或這 postDedayXXX發送消息後，最終會調用到SendMessageAtTime方法中。
然後調用MessageQueue.enqueueMessage將消息存到消息隊列中。
存入消息後，然後通過調用native方法 喚醒主線程進行消息處理。
當應用程序啟動，做完一些必要工作之後，便會開啟Loop循環，除非系統異常，否則該循環不會停止。loop循環中，主要做兩件事，第一，從消息隊列中取消息。第二，進行消息分發處理。
MessageQueue.next() 方法 通過調用 native方法 nativePollOnce(ptr, nextPollTimeoutMillis)實現無消息處理時，進入阻塞的功能。
當nextPollTimeoutMillis 值為0時，該方法會立刻返回；
當nextPollTimeoutMillis 值為-1時，該方法會無限阻塞，直到被喚醒；
當nextPollTimeoutMillis 值大於0時，該方法會將該值設置為超時時間，阻塞到達一定時間後，返回；
在loop循環中 ，通過調用 msg.target.dispatchMessage(msg) 進行消息的分發處理
使用當前線程的MessageQueue.addIdleHandler方法可以在消息隊列中添加一個IdelHandler。
當MessageQueue 阻塞時，即當前線程空閑時，會回調IdleHandler中的方法；
當IdelHandler介面返回false時，表示該IdelHandler只執行一次，
a，延遲執行
例如，當啟動Activity時，需要延時執行一些操作，以免啟動過慢，我們常常使用以下方式延遲執行任務，但是在延遲時間上卻不好控制。
其實，這時候使用IdelHandler 會更優雅
b，批量任務，任務密集，且只關注最終結果
例如，在開發一個IM類型的界面時，通常情況下，每次收到一個IM消息時，都會刷新一次界面，但是當短時間內， 收到多條消息時，就會刷新多次界面，容易造成卡頓，影響性能，此時就可以使用一個工作線程監聽IM消息，在通過添加IdelHandler的方式通知界面刷新，避免短時間內多次刷新界面情況的發生。
在Android的消息機制中，其實有三種消息: 普通消息、非同步消息及消息屏障。
消息屏障 也是一種消息，但是它的target為 null。可以通過MessageQueue中的postSyncBarrier方法發送一個消息屏障（該方法為私有，需要反射調用）。
在消息循環中，如果第一條消息就是屏障消息，就往後遍歷，看看有沒有非同步消息:
如果沒有，則無限休眠，等待被喚醒
如果有，就看離這個消息被觸發時間還有多久，設置一個超時時間，繼續休眠
非同步消息 和普通消息一樣，只不過它被設置setAsynchronous 為true。有了這個標志位，消息機制會對它有些特別的處理，我們稍後說。
所以 消息屏障和非同步消息的作用 很明顯，在設置消息屏障後，非同步消息具有優先處理的權利。
這時候我們回顧將消息添加到消息隊列中時，可以發現，其實並不是每一次添加消息時，都會喚醒線程。
當該消息插入到隊列頭時，會喚醒該線程；
當該消息沒有插入到隊列頭，但隊列頭是屏障，且該消息是隊列中 靠前的一個非同步消息，則會喚醒線程，執行該消息；
調用MessageQueue.removeSyncBarrier 方法可以移除指定的消息屏障
ANR 即 Application Not Response， 是系統進程對應用行為的一種監控，如果應用程序沒有在規定時間內完成任務的話，就會引起ANR。
ANR類型
Service Timeout : 前台服務20s, 後台服務200s
BroadcastQueue Timeout : 前台廣播 10s，後台廣播60s
ContentPrivider Timeout : 10s
InputDispatching Timeout : 5s
比如，在啟動一個服務時， AMS端通過應用進程的Binder對象創建Service, 在scheleCreateService()方法中 會調用到當前service的onCreate()生命周期函數；
bumpServiceExecutingLocked()方法內部實際上會調用到scheleServiceTimeoutLocked()方法，發送一個ActivityManagerService.SERVICE_TIMEOUT_MSG類型消息到AMS工作線程中。
消息的延時時間，如果是前台服務，延時20s, 如果是後台服務，延時200s;
如果Service的創建 工作在 上訴消息的延時時間內完成，則會移除該消息，
否則，在Handler正常收到這個消息後，就會進行服務超時處理，即彈出ANR對話框。
復雜情況下，可能會頻繁調用sendMessage 往消息隊列中，添加消息，導致消息積壓，造成卡頓，
1，重復消息過濾
頻繁發送同類型消息時，有可能隊列中之前的消息還沒有處理，又發了一條相同類型的消息，更新之前的數據，這時候，可以採用移除前一個消息的方法，優化消息隊列。
2，互斥消息取消
在發送消息時，優先將消息隊列中還未處理的信息已經過時的消息 移除，優化隊列
3，隊列優化-復用消息
創建消息時，優先採用之前回收的消息，避免重復創建對象，引起GC
完~
（如果錯誤或不足，望指出， 大家共同進步）
③ Android中Handler的使用方法
主線程中創建handlerhandler的引用注入到adapteradapter里通過handler的引用發送message主線程中處理message
④ 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 的API的handler翻譯
繼承順序:java.lang.Object-->android.os.Handler
直接子類：AsyncQueryHandler,HttpAuthHandler,SslErrorHandler
public class Handler extends Object
一個Handler允許你傳遞、處理Message和Runnable對象，通過相關聯的thread的消息隊列（MessageQueue）.每個handler實例都與一個thread相關聯和特定的消息隊列。當你創建了一個新的Handler，他就綁定到了這個thread的thread或者message隊列，而這個thread從創建的地點將傳遞消息和runnables到那個消息隊列，且處理那些從消息隊列中出來消息。
有兩種主要的使用方式，1、有計劃的處理message和runnable，在未來的某個時刻。2、在非你的另外的線程上執行一個方法。
計劃消息使用下列方法處理：post(java.lang.Runnable),postAtTime(Runnable,long),postDelayer(java.lang.Runnable,long),sendEmptyMessage(int),sendMessage(android.os.Message),sendMessageAtTime(android.os.Message,long),和sendMessageDelayed(android.os.Message,long)。消息隊列調用post方法允許你講Runnable對象壓入隊列，當被接收的時候。當Handler的handleMessage方法處理一束Message包含的數據的時候，允許你壓入message進入隊列（需要你實現一個Handler的子類）。
當提交或者傳遞一個Handler的時候，你既可以讓item處理與消息隊列准備好一樣快，或者指定一個延遲在他被處理或者被處理前的絕對時間間隔。後兩者需要你實現時間、軌跡和其他的時間基本行為。
當應用創建好一個process，他的主線程決定運行一個消息隊列，這個隊列接管著應用最高等級的對象（activities,broadcast,receivers,etc）和他們創建的任意的窗口。你可以創建你的自己的threads和通訊，通過一個Handler與主線程完成回調。在完成之前調用相同的post或者sendMessage方法，但是通過新的thread.給定的Runnable或者Message將被添加到Handler的消息隊列，且在適當的時候完成處理。
一、嵌套類摘要
Handler.Callback
在你實例化一個Handler的時候你可以使用Callback介面用來避免必須實現你自己的Handler子類。、
二、構造方法摘要
Handler()
默認的構造方法使得該handler與當前的thread隊列相關聯。
Handler(Handler.Callback callback)
與當前的thread隊列想關聯且在回調介面中可以處理message
Handler(Looper looper)
使用自定義的隊列代替默認的隊列。
Handler(Looper looper,Handler.Callback callback)
使用自定義的隊列代替默認的隊列且在回調介面中處理message
三、方法摘要
dispatchMessage(Message msg):處理系統的信息
mp(Printer pw, String prefix)
getLooper()
handleMessage(Message msg)子類必須實現這個來接收消息
hasMessage(int what):檢查消息中的what是否含有消息且obj在隊列中是否是對象。
obtainMessage():從全局message池返回一個新的Message
obtainMessage(int what):功能同上，除了能夠設置返回消息中的member屬性
obtainMessage(int what,int arg1,int arg2):功能同obtainMessage()，除了能設置what arg1, arg2這些屬性。
obtainMessage(int what,int arg1,int arg2,Object obj):功能同不帶參數的方法，除了能夠設置what ,obj,arg1,arg2值。
obtainMessage(int what,Object obj):功能同無參數方法一樣，除了能設置what和obj屬性值。
post(Runnable r):使得Runnable r添加到消息隊列。
postAtFrontOfQueue(Runnable r):提交一個消息到一個實現了Runnable的對象
postAtTime(Runnable r,long uptimeMillis):使得Runnable r被添加到消息隊列，在由uptimeMills給定的特定時間
postAtTime(Runnable r , Object token, long uptimeMills):使得Runnable r添加到消息隊列，在由uptimeMills給定的特定時間運行。
postDelayer(Runnable r , long delayMillis):使得Runnable r被添加到隊列，在由指定的時間後運行。
removeCallbacks(Runnable r):移除在消息隊列中的沒有提交的Runnable r
removeCallbacks(Runnable r,Object token):移除在消息隊列中使用Object 的token的沒有提交的Runnable r.
removeCallbacksAndMessage(Object token):移除在回調函數中沒有提交的消息且發送消息的obj是token
void removeMessages (int what)
Remove any pending posts of messages with code 'what' that are in the message queue.
void removeMessages (int what, Object object)
Remove any pending posts of messages with code 'what' and whose obj is 'object' that are in the message queue.
boolean sendEmptyMessage (int what)
Sends a Message containing only the what value.
boolean sendEmptyMessageAtTime (int what, long uptimeMillis)
Sends a Message containing only the what value, to be delivered at a specific time.
boolean sendEmptyMessageDelayed (int what, long delayMillis)
Sends a Message containing only the what value, to be delivered after the specified amount of time elapses.
boolean sendMessage ( Message msg)
Pushes a message onto the end of the message queue after all pending messages before the current time.
boolean sendMessageAtFrontOfQueue ( Message msg)
Enqueue a message at the front of the message queue, to be processed on the next iteration of the message loop.
boolean sendMessageAtTime ( Message msg, long uptimeMillis)
Enqueue a message into the message queue after all pending messages before the absolute time (in milliseconds)uptimeMillis.
boolean sendMessageDelayed ( Message msg, long delayMillis)
Enqueue a message into the message queue after all pending messages before (current time + delayMillis).
String toString ()
Returns a string containing a concise, human-readable description of this object.
⑥ android中handler的使用
Handler這部分我也在用，模仿例子套著用，主要用於子線程向主程序發消息，讓Handler對象處理。你的疑問我也有，這new Handler（）｛｝，只是一瞬間就結束的，可它仍時刻監視著自已的消息以便隨時再處理，這似乎有點不符常規令人不解，但細想一下，這就象一個按鈕控制項對象，
你點擊一下，它就能響應一次點擊處理事件。
⑦ Android中介紹Handler的幾種用法
第一種
第二種
第三種
如果還有其他用法，請高人賜教。
ps：孔乙己先生，handler有幾種用法啊！
⑧ Android Handler消息機制
跨線程通信。當子線程中進行耗時操作後需要更新UI時，通過Handler將有關UI的操作切換到主線程中執行。
四要素：
Message（消息）：需要被傳遞的消息，其中包含了消息ID，消息處理對象以及處理的數據等，由MessageQueue統一列隊，最終由Handler處理。
MessageQueue（消息隊列）：用來存放Handler發送過來的消息，內部通過單鏈表的數據結構來維護消息列表，等待Looper的抽取。
Handler（處理者）：負責Message的發送及處理。通過 Handler.sendMessage() 向消息池發送各種消息事件；通過 Handler.handleMessage() 處理相應的消息事件。
Looper（消息泵）：通過Looper.loop()不斷地從MessageQueue中抽取Message，按分發機制將消息分發給目標處理者。
Handler.sendMessage()發送消息時，會通過MessageQueue.enqueueMessage()向MessageQueue中添加一條消息；
通過Looper.loop()開啟循環後，不斷輪詢調用MessageQueue.next()；
調用目標Handler.dispatchMessage()去傳遞消息，目標Handler收到消息後調用Handler.handlerMessage()處理消息。
⑨ Android Handler機制 怎麼用
Handler對象與其調用者在同一線程中，如果在Handler中設置了延時操作，則調用線程也會堵塞。每個Handler對象都會綁定一個Looper對象，每個Looper對象對應一個消息隊列（MessageQueue）。如果在創建Handler時不指定與其綁定的Looper對象，系統默認會將當前線程的Looper綁定到該Handler上。
在主線程中，可以直接使用new Handler()創建Handler對象，其將自動與主線程的Looper對象綁定；在非主線程中直接這樣創建Handler則會報錯，因為Android系統默認情況下非主線程中沒有開啟Looper，而Handler對象必須綁定Looper對象。這種情況下，需先在該線程中手動開啟Looper（Looper.prepare()-->Looper.loop()），然後將其綁定到Handler對象上；或者通過Looper.getMainLooper()，獲得主線程的Looper，將其綁定到此Handler對象上。
Handler發送的消息都會加入到Looper的MessageQueue中。一說Handler包含兩個隊列：線程隊列和消息隊列；使用Handler.post()可以將線程對象加入到線程隊列中；使用Handler.sendMessage()可以將消息對象加入到消息隊列中。通過源碼分析證實，Handler只有一個消息隊列，即MessageQueue。通過post()傳進去的線程對象將會被封裝成消息對象後傳入MessageQueue。
使用post()將線程對象放到消息隊列中後，當Looper輪詢到該線程執行時，實際上並不會單獨開啟一個新線程，而仍然在當前Looper綁定的線程中執行，Handler只是調用了該線程對象的run()而已。如，在子線程中定義了更新UI的指令，若直接開啟將該線程執行，則會報錯；而通過post()將其加入到主線程的Looper中並執行，就可以實現UI的更新。
使用sendMessage()將消息對象加入到消息隊列後，當Looper輪詢到該消息時，就會調用Handler的handleMessage()來對其進行處理。再以更新UI為例，使用這種方法的話，就先將主線程的Looper綁定在Handler對象上，重載handleMessage()來處理UI更新，然後向其發送消息就可以了。
⑩ 能講講Android的Handler機制嗎
Android的Handler機制是通俗講為了互相發消息，一般是子線程給主線程發消息完成相應操作。
安卓中最常見的操作是子線程操作完事後得到數據想更新UI，安卓有規定不允許在子線程中刷新UI，所以Handler出現了。
使用和理解大致步驟。
創建全局Handler對象handler，然後在主線程中初始化它（一般在oncreate中），把它的handmessage裡面的方法重寫，這個方法是收到子線程發給它的消息後執行的邏輯。
在子線程中獲取數據，調用handler.sendmessage，把要發的消息放在message中。message會添加到Messagequue(消息隊列中，handler創建就帶的)。
3.對象handler被創建和初始化的時候，系統自動會啟動Handler.looper,也就是一個消息輪詢器，它不斷的去查看有沒有消息進入到Messagequue(消息隊列中)，有就取出交給handler的handmessage去處理。//這段邏輯是系統自動執行，理解就行。*純手打，不騙人~~~