android消息隊列

A. Andriod是不是每個線程都有消息隊列

你好
很高興為你解答

答案是：
熟悉Windows編程的朋友可能知道Windows程序是消息驅動的，並且有全局的消息循環系統。而android應用程序也是消息驅動的，按道 理來說也應該提供消息循環機制。實際上谷歌參考了Windows的消息循環機制，也在Android系統中實現了消息循環機制。Android通過 Looper、Handler來實現消息循環機制，Android消息循環是針對線程的（每個線程都可以有自己的消息隊列和消息循環）。本文深入介紹一下 Android消息處理系統原理。
前面提到Android系統的消息隊列和消息循環都是針對具體線程的，一個線程可以存在（當然也可以不存在）一個消息隊列和一個消息循環 （Looper），特定線程的消息只能分發給本線程，不能進行跨線程，跨進程通訊。但是創建的工作線程默認是沒有消息循環和消息隊列的，如果想讓該線程具 有消息隊列和消息循環，需要在線程中首先調用Looper.prepare()來創建消息隊列，然後調用Looper.loop()進入消息循環。

滿意請採納，謝謝

B. android里的所有事件都是基於消息隊列的嗎

Android廣播分為兩個方面：廣播發送者和廣播接收者，通常情況下，BroadcastReceiver指的就是廣播接收者（廣播接收器）。廣播作為Android組件間的通信方式，可以使用的場景如下：1.同一app內部的同一組件內的消息通信（單個或多個線程之間）。2.同一app內部的不同組件之間的消息通信（單個進程）。3.同一app具有多個進程的不同組件之間的消息通信。4.不同app之間的組件之間消息通信。5.Android系統在特定情況下與App之間的消息通信。從實現原理看上，Android中的廣播使用了觀察者模式，基於消息的發布/訂閱事件模型。因此，從實現的角度來看，Android中的廣播將廣播的發送者和接受者極大程度上解耦，使得系統能夠方便集成，更易擴展。具體實現流程要點粗略概括如下：1.廣播接收者BroadcastReceiver通過Binder機制向AMS(Activity Manager Service)進行注冊；2.廣播發送者通過binder機制向AMS發送廣播；3.AMS查找符合相應條件（IntentFilter/Permission等）的BroadcastReceiver，將廣播發送到BroadcastReceiver（一般情況下是Activity）相應的消息循環隊列中；4.消息循環執行拿到此廣播，回調BroadcastReceiver中的onReceive()方法。 對於不同的廣播類型，以及不同的BroadcastReceiver注冊方式，具體實現上會有不同。但總體流程大致如上。

C. 如何抓取廣播隊列消息 android

下面和大家分享一下android中非常重要的消息處理機制，說到消息處理，Message,MessageQueue,Looper,Handler這四個類的作用是我們必須要明白的。 下面分別談談他們的作用： MessageQueue MessageQueue表示消息隊列，存放消息的地方，按照「先進先..則執行，每一個線程只可以擁有一個MessageQueue。當創建Looper對象的時候會創建一個MessageQueue對象。

Message

Message表示消息對象，MessageQueue中存放的對象，一個MessageQueue中可以存放多個Message對象。通過調用Message類的obtain()方法或者調用Handler類的obtainMessage()方法獲取Message對象，但是這樣並不一定會創建一個新的Message對象，如果消息池中有可用的Message對象則直接取出返回這個對象，否則如果消息池中沒有可用的Message對象，則會創建一個新的Message對象。當消息隊列中的Message對象被系統處理完之後，該Message對象會從MessageQueue中刪除，然後放入消息池中。

Looper

Looper是用來操作MessageQueue的，每一個Looper對應一個MessageQueue，可以通過調用Looper.myLooper()方法獲取當前線程的Looper對象，Looper循環從MessageQueue中取出Message對象，交給Handler調用handleMessage方法進行處理，處理完之後Message對象被放入消息池中。

Handler

Handler是消息的處理者，Handler將需要傳遞的信息封裝成Message對象，然後調用sendMessage方法將Message放入MessageQueue中，當MessageQueue循環到該Message時，調用相應Handler對象的handleMessage方法對其進行處理。 http://d-android.com/developer/
注意在UI線程也就是主線程中默認會創建Looper對象和MessageQueue對象，如果在我們自己新開的線程中要進行消息處理，必須創建Looper對象和MessageQueue對象，通過調用Looper.prepare()方法可以創建Looper對象和MessageQueue對象，調用Looper.loop()方法可以啟動消息循環隊列。

D. android中主線程會創建消息隊列嗎

一、Handler的定義: Handler主要接收子線程發送的數據, 並用此數據配合主線程更新UI，用來跟UI主線程交互用。比如可以用handler發送一個message，然後在handler的線程中來接收、處理該消息，以避免直接在UI主線程中處理事務導致影響UI主線程的其他處理工作，Android提供了Handler作為主線程和子線程的紐帶；也可以將handler對象傳給其他進程，以便在其他進程中通過handler給你發送事件；還可以通過handler的延時發送message，可以延時處理一些事務的處理。 通常情況下，當應用程序啟動時，Android首先會開啟一個主線程 (也就是UI線程) , 主線程為管理界面中的UI控制項，進行事件分發。如果此時需要一個耗時的操作，例如:聯網讀取數據，或者讀取本地較大的一個文件的時候，你不能把這些操作放在主線程中，如果你放在主線程中的話，界面會出現假死現象,如果5秒鍾還沒有完成的話，會收到Android系統的一個錯誤提示"強制關閉". 這個時候我們需要把這些耗時的操作，放在一個子線程中,因為子線程涉及到UI更新，但是當子線程中有涉及到操作UI的操作時，就會對主線程產生危險，也就是說，更新UI只能在主線程中更新，在子線程中操作是危險的. 這個時候，Handler就出現了來解決這個復雜的問題，由於Handler運行在主線程中(UI線程中)，它與子線程可以通過Message對象來傳遞數據，這個時候，Handler就承擔著接受子線程傳過來的(子線程用sedMessage()方法傳遞)Message對象，(裡麵包含數據), 把這些消息放入主線程隊列中，配合主線程進行更新UI。 二、Handler一些特點 handler可以分發Message對象和Runnable對象到主線程中, 每個Handler實例,都會綁定到創建他的線程中(一般是位於主線程), 也就是說Handler對象初始化後，就默認與對它初始化的進程的消息隊列綁定，因此可以利用Handler所包含的消息隊列，制定一些操作的順序。 三、Handler中分發消息的一些方法 post(Runnable) postAtTime(Runnable,long) postDelayed(Runnable long) post類方法允許你排列一個Runnable對象到主線程隊列中 sendEmptyMessage(int) sendMessage(Message) sendMessageAtTime(Message,long) sendMessageDelayed(Message,long) sendMessage類方法, 允許你安排一個帶數據的Message對象到隊列中，等待更新. 四、應用實例： 1，傳遞Message。用於接受子線程發送的數據, 並用此數據配合主線程更新UI。 在Android中，對於UI的操作通常需要放在主線程中進行操作。如果在子線程中有關於UI的操作，那麼就需要把數據消息作為一個Message對象發送到消息隊列中，然後，用Handler中的handlerMessge方法處理傳過來的數據信息，並操作UI。類sendMessage(Message msg)方法實現發送消息的操作。 在初始化Handler對象時重寫的handleMessage方法來接收Messgae並進行相關操作。 2，傳遞Runnable對象。用於通過Handler綁定的消息隊列，安排不同操作的執行順序。 Handler對象在進行初始化的時候，會默認的自動綁定消息隊列。利用類post方法，可以將Runnable對象發送到消息隊列中，按照隊列的機制按順序執行不同的Runnable對象中的run方法。 另外，Android的CPU分配的最小單元是線程，Handler一般是在某個線程里創建的，因而Handler和Thread就是相互綁定的，一一對應。而Runnable是一個介面，Thread是Runnable的子類。所以說，他倆都算一個進程。 視頻教程中的例子： 1. public class HandlerActivity extends Activity { 2. 3. //聲明兩個按鈕控制項 4. private Button startButton = null; 5. private Button endButton = null; 6. @Override 7. public void onCreate(Bundle savedInstanceState) { 8. super.onCreate(savedInstanceState); 9. setContentView(R.layout.main); 10. //根據控制項的ID得到代表控制項的對象，並為這兩個按鈕設置相應的監聽器 11. startButton = (Button)findViewById(R.id.startButton); 12. startButton.setOnClickListener(new StartButtonListener()); 13. endButton = (Button)findViewById(R.id.endButton); 14. endButton.setOnClickListener(new EndButtonListener()); 15. 16. } 17. class StartButtonListener implements OnClickListener{ 18. 19. @Override 20. public void onClick(View v) { 21. //調用Handler的post方法，將要執行的線程對象添加到隊列當中 22. handler.post(updateThread); 23. } 24. 25. } 26. 27. class EndButtonListener implements OnClickListener{ 28. 29. @Override 30. public void onClick(View v) { 31. handler.removeCallbacks(updateThread); 32. } 33. 34. } 35. //創建一個Handler對象 36. Handler handler = new Handler(); 37. //將要執行的操作寫在線程對象的run方法當中 38. Runnable updateThread = new Runnable(){ 39. 40. @Override 41. public void run() { 42. System.out.println("UpdateThread"); 43. //在run方法內部，執行postDelayed或者是post方法 44. handler.postDelayed(updateThread, 3000); 45. } 46. 47. }; 48. } 程序的運行結果就是每隔3秒鍾，就會在控制台列印一行UpdateTread。這是因為實現了Runnable介面的updateThread對象進入了空的消息隊列即被立即執行run方法，而在run方法的內部，又在3000ms之後將其再次發送進入消息隊列中。 3， Handler和多線程 post方法雖然發送的是一個實現了Runnable介面的類對象，但是它並非創建了一個新線程，而是執行了該對象中的run方法。也就是說，整個run中的操作和主線程處於同一個線程。 這樣對於那些簡單的操作，似乎並不會影響。但是對於耗時較長的操作，就會出現「假死」。為了解決這個問題，就需要使得handler綁定到一個新開啟線程的消息隊列上，在這個處於另外線程的上的消息隊列中處理傳過來的Runnable對象和消息。 1. public class HandlerTest2 extends Activity { 2. 3. @Override 4. protected void onCreate(Bundle savedInstanceState) { 5. // TODO Auto-generated method stub 6. super.onCreate(savedInstanceState); 7. setContentView(R.layout.main); 8. //列印了當前線程的ID 9. System.out.println("Activity-->" + Thread.currentThread().getId()); 10. //生成一個HandlerThread對象 11. HandlerThread handlerThread = new HandlerThread("handler_thread"); 12. //在使用HandlerThread的getLooper()方法之前，必須先調用該類的start()，同時開啟一個新線程; 13. handlerThread.start(); 14. //將由HandlerThread獲取的Looper傳遞給Handler對象，即由處於另外線程的Looper代替handler初始化時默認綁定的消息隊列來處理消息。 15. // HandlerThread顧名思義就是可以處理消息循環的線程，它是一個擁有Looper的線程 16. ，可以處理消息循環； 其實與其說Handler和一個線程綁定，倒不如說Handler和Looper是 17. 一一對應的。 18. MyHandler myHandler = new MyHandler(handlerThread.getLooper()); 19. Message msg = myHandler.obtainMessage(); 20. //將msg發送到目標對象，所謂的目標對象，就是生成該msg對象的handler對象 21. Bundle b = new Bundle(); 22. b.putInt("age", 20); 23. b.putString("name", "Jhon"); 24. msg.setData(b); 25. msg.sendToTarget(); //將msg發送到myHandler 26. } 27. 28. //定義類 29. class MyHandler extends Handler{ 30. public MyHandler(){ 31. 32. } 33. 34. public MyHandler(Looper looper){ 35. super(looper); 36. } 37. @Override 38. public void handleMessage(Message msg) { 39. Bundle b = msg.getData(); 40. int age = b.getInt("age"); 41. String name = b.getString("name"); 42. System.out.println("age is " + age + ", name is" + name); 43. System.out.println("Handler--->" + Thread.currentThread().getId()); 44. System.out.println("handlerMessage"); 45. } 46. } 47. } 這樣，當使用sendMessage方法傳遞消息或者使用post方法傳遞Runnable對象時，就會把它們傳遞到與handler對象綁定的處於另外一個線程的消息隊列中，它們將在另外的消息隊列中被處理。而主線程還會在發送操作完成時候繼續進行，不會影響當前的操作。 這里需要注意，這里用到的多線程並非由Runnable對象開啟的，而是ThreadHandler對象開啟的。Runnable對象只是作為一個封裝了操作的對象被傳遞，並未產生新線程。 另外再強調一遍，在UI線程（主線程）中： mHandler=new Handler(); mHandler.post(new Runnable(){ void run(){ //執行代碼.. } }); 這個線程其實是在UI線程之內運行的，並沒有新建線程。 常見的新建線程的方法是： Thread thread = new Thread(); thread.start(); HandlerThread thread = new HandlerThread("string"); thread.start();

E. 如何生動形象的理解Android Handler消息處理機制

在一個Android 程序開始運行的時候，會單獨啟動一個Process。默認的情況下，所有這個程序中的Activity，Service，Content Provider，Broadcast Receiver（Android 4大組件）都會跑在這個Process。一個Android 程序默認情況下也只有一個Process，但一個Process下卻可以有許多個Thread。在這么多Thread當中，有一個Thread，稱之為UI Thread。UI Thread在Android程序運行的時候就被創建，是一個Process當中的主線程Main Thread，主要是負責控制UI界面的顯示、更新和控制項交互。在Android程序創建之初，一個Process呈現的是單線程模型，所有的任務都在一個線程中運行。因此，UI Thread所執行的每一個函數，所花費的時間都應該是越短越好。而其他比較費時的工作（訪問網路，下載數據，查詢資料庫等），都應該交由子線程去執行，以免阻塞主線程，導致ANR。那麼問題來了，UI 主線程和子線程是怎麼通信的呢。這就要提到這里要講的Handler機制。
簡單來說，handler機制被引入的目的就是為了實現線程間通信的。handler一共幹了兩件事：在子線程中發出message，在主線程中獲取、處理message。聽起來好像so easy，如果面試中讓闡述下Handler機制，這么回答顯然不是面試官想要的答案。忽略了一個最重要的問題：子線程何時發送message，主線程何時獲取處理message。
為了能讓主線程「適時」得處理子線程所發送的message，顯然只能通過回調的方式來實現——開發者只要重寫Handler類中處理消息的方法，當子線程發送消時，Handler類中處理消息的方法就會被自動回調。
Handler類包含如下方法用於發送處理消息
void handleMessage（Message msg）：處理消息的方法，該方法通常用於被重寫。
final boolean hasMessage（int what）：檢查消息隊列中是否包含what屬性為指定值的消息。
final boolean hasMessage（int what，Object object）：檢查消息隊列中是否包含what屬性為指定值且object屬性為指定對象的消息。
sendEmptyMessage（int what）發送空消息。
sendEmptyMessageDelayed（int what，longdelayMillis）；指定多少毫秒之後發送空消息。
sendMessage（Message msg）立即發送消息。
sendMessageDelayed（int what，longdelayMillis）；指定多少毫秒之後發送消息。
藉助以上方法，就可以自由穿梭於主線程和子線程之中了。
到這里就結束了么？當然沒有。要講的東西才剛剛開始，要知道消息處理這件事，不是handler一個人在戰斗，android的消息處理有三個核心類：Handler，Looper,和Message。其實還有一個MessageQueue（消息隊列），但是Message Queue被封裝到Looper裡面了，不會直接與Message Queue打交道。
Looper的字面意思是「循環裝置」，它被設計用來使一個普通線程變成Looper線程。所謂Looper線程就是循環工作的線程。在程序開發中，經常會需要一個線程不斷循環，一旦有新任務則執行，執行完繼續等待下一個任務，這就是Looper線程。Looper是用於給一個線程添加一個消息隊列(MessageQueue)，並且循環等待，當有消息時會喚起線程來處理消息的一個工具，直到線程結束為止。通常情況下不會用到Looper，因為對於Activity，Service等系統組件，Frameworks已經為初始化好了線程(俗稱的UI線程或主線程)，在其內含有一個Looper，和由Looper創建的消息隊列，所以主線程會一直運行，處理用戶事件，直到某些事件(BACK）退出。
如果，需要新建一個線程，並且這個線程要能夠循環處理其他線程發來的消息事件，或者需要長期與其他線程進行復雜的交互，這時就需要用到Looper來給線程建立消息隊列。
使用Looper也非常的簡單，它的方法比較少，最主要的有四個:
public static prepare();為線程初始化消息隊列。
public static myLooper();獲取此Looper對象的引用
public static loop();讓線程的消息隊列開始運行，可以接收消息了。
public void quit();退出具體哪個Looper
在整個消息處理機制中，message又叫task，封裝了任務攜帶的信息和處理該任務的handler，這個很好理解，就不做介紹了。
說了這么多，一定沒聽太明白。沒關系，再對Handler運行機製做個總結：
子線程（無looper）借用主線程（有looper）里的Hander發送一條message到主線程，這個message會被主線程放入message queue，主線程裡面有一個looper，在輪詢message queue的時候發現有一條message。調用handler消息處理者，執行handlemessage方法，去處理這個message，就可以在handlemessage的方法裡面更新ui。好像畫面感不是太強，舉個例子吧。試想有一個生產方便麵的車間，這個車間有兩條生產線，一條是生產面餅的，一條是生產調料包的，面餅的生產線比較先進一點，配備了一個工人叫handler，還配備了一個調料包分類循環器。這個車間能生產很多種方便麵，有老壇酸菜，有泡椒鳳爪，有香菇燉雞，有紅燒牛肉等等。其中方便麵的面餅都是一樣的，只有調料包和包裝袋不一樣，包裝袋是根據調料包來定的。那麼生產線運作起來了:工人Handler把子生產線（子線程）上的調料包（message）放到了主生產線（主線程）上的調料包分類循環器（Looper）上，通過輪詢分類篩選後工人Handler確定這是一包合格的老壇酸菜味調料包，於是工人把老壇酸菜調料包和面餅放在一塊（sendmessage），告訴主生產線，這是一包老壇酸菜方便麵，請給這包方便麵包一個老壇酸菜的包裝袋（更新UI）.

F. 引起android 消息隊列堵塞的原因有哪些

耗時的工作放在了主線程
無限循環

G. 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做支撐。

H. 請簡述什麼是android事件處理，並分析兩種android事件處理機制的實現過程和區別

UI編程通常都會伴隨事件處理，Android也不例外，它提供了兩種方式的事件處理：基於回調的事件處理和基於監聽器的事件處理。

對於基於監聽器的事件處理而言，主要就是為Android界面組件綁定特定的事件監聽器；對於基於回調的事件處理而言，主要做法是重寫Android組件特定的回調函數，Android大部分界面組件都提供了事件響應的回調函數，我們主要重寫它們就行。

一 基於監聽器的事件處理

相比於基於回調的事件處理，這是更具「面向對象」性質的事件處理方式。在監聽器模型中，主要涉及三類對象：

1）事件源Event Source：產生事件的來源，通常是各種組件，如按鈕，窗口等。

2）事件Event：事件封裝了界面組件上發生的特定事件的具體信息，如果監聽器需要獲取界面組件上所發生事件的相關信息，一般通過事件Event對象來傳遞。

3）事件監聽器Event Listener：負責監聽事件源發生的事件，並對不同的事件做相應的處理。

基於監聽器的事件處理機制是一種委派式Delegation的事件處理方式，事件源將整個事件委託給事件監聽器，由監聽器對事件進行響應處理。這種處理方式將事件源和事件監聽器分離，有利於提供程序的可維護性。

舉例：

View類中的OnLongClickListener監聽器定義如下：（不需要傳遞事件）

[java] view plainprint?

public interface OnLongClickListener {

boolean onLongClick(View v);

}

public interface OnLongClickListener {
boolean onLongClick(View v);
}

View類中的OnLongClickListener監聽器定義如下：（需要傳遞事件MotionEvent）

[java] view plainprint?

public interface OnTouchListener {

boolean onTouch(View v, MotionEvent event);

}

public interface OnTouchListener {
boolean onTouch(View v, MotionEvent event);
}

二 基於回調的事件處理

相比基於監聽器的事件處理模型，基於回調的事件處理模型要簡單些，該模型中，事件源和事件監聽器是合一的，也就是說沒有獨立的事件監聽器存在。當用戶在GUI組件上觸發某事件時，由該組件自身特定的函數負責處理該事件。通常通過重寫Override組件類的事件處理函數實現事件的處理。

舉例：

View類實現了KeyEvent.Callback介面中的一系列回調函數，因此，基於回調的事件處理機制通過自定義View來實現，自定義View時重寫這些事件處理方法即可。

[java] view plainprint?

public interface Callback {

// 幾乎所有基於回調的事件處理函數都會返回一個boolean類型值，該返回值用於

// 標識該處理函數是否能完全處理該事件

// 返回true，表明該函數已完全處理該事件，該事件不會傳播出去

// 返回false，表明該函數未完全處理該事件，該事件會傳播出去

boolean onKeyDown(int keyCode, KeyEvent event);

boolean onKeyLongPress(int keyCode, KeyEvent event);

boolean onKeyUp(int keyCode, KeyEvent event);

boolean onKeyMultiple(int keyCode, int count, KeyEvent event);

}

public interface Callback {
// 幾乎所有基於回調的事件處理函數都會返回一個boolean類型值，該返回值用於
// 標識該處理函數是否能完全處理該事件
// 返回true，表明該函數已完全處理該事件，該事件不會傳播出去
// 返回false，表明該函數未完全處理該事件，該事件會傳播出去
boolean onKeyDown(int keyCode, KeyEvent event);
boolean onKeyLongPress(int keyCode, KeyEvent event);
boolean onKeyUp(int keyCode, KeyEvent event);
boolean onKeyMultiple(int keyCode, int count, KeyEvent event);
}

三 比對

基於監聽器的事件模型符合單一職責原則，事件源和事件監聽器分開實現；

Android的事件處理機制保證基於監聽器的事件處理會優先於基於回調的事件處理被觸發；

某些特定情況下，基於回調的事件處理機制會更好的提高程序的內聚性。

四 基於自定義監聽器的事件處理流程

在實際項目開發中，我們經常需要自定義監聽器來實現自定義業務流程的處理，而且一般都不是基於GUI界面作為事件源的。這里以常見的app自動更新為例進行說明，在自動更新過程中，會存在兩個狀態：下載中和下載完成，而我們的程序需要在這兩個狀態做不同的事情，「下載中」需要在UI界面上實時顯示軟體包下載的進度，「下載完成」後，取消進度條的顯示。這里進行一個模擬，重點在說明自定義監聽器的事件處理流程。

4.1）定義事件監聽器如下：

I. android怎樣編寫延時消息隊列

最早的時候我下過一個2005EE版，怎麼也安裝不上，後來發現原來是EE不支持xp =_= ， 然後就下 .... 本機沒有安裝過消息隊列，找出系統盤安裝消息隊列組件，在組件安裝中

J. 簡述android多線程機制

Handler對象與其調用者在同一線程中，如果在Handler中設置了延時操作，則調用線程也會堵塞。每個Handler對象都會綁定一個Looper對象，每個Looper對象對應一個消息隊列（MessageQueue）。如果在創建Handler時不指定與其綁定的Looper對象，系統默認會將當前線程的Looper綁定到該Handler上。在主線程中，可以直接使用newHandler()創建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更新，然後向其發送消息就可以了。