Looper，Handler，Message

android的消息處理有三個核心類：Looper,Handler和Message。其實還有一個Message Queue（消息隊列），但是MQ被封裝到Looper裏面了，我們不會直接與MQ打交道，因此我沒將其作爲核心類。下面一一介紹：

線程的魔法師 Looper

Looper的字面意思是“循環者”，它被設計用來使一個普通線程變成Looper線程。所謂Looper線程就是循環工作的線程。在程序開發中（尤其是GUI開發中），我們經常會需要一個線程不斷循環，一旦有新任務則執行，執行完繼續等待下一個任務，這就是Looper線程。使用Looper類創建Looper線程很簡單：

複製代碼代碼如下:

publicclass LooperThread extends Thread { 
@Override 
publicvoid run() { 
// 將當前線程初始化爲Looper線程 
Looper.prepare(); 

// ...其他處理，如實例化handler 

// 開始循環處理消息隊列 
Looper.loop(); 
} 
} 

通過上面兩行核心代碼，你的線程就升級爲Looper線程了！！！是不是很神奇？讓我們放慢鏡頭，看看這兩行代碼各自做了什麼。

1)Looper.prepare()

通過上圖可以看到，現在你的線程中有一個Looper對象，它的內部維護了一個消息隊列MQ。注意，一個Thread只能有一個Looper對象，爲什麼呢？咱們來看源碼。

複製代碼代碼如下:

publicclass Looper { 
// 每個線程中的Looper對象其實是一個ThreadLocal，即線程本地存儲(TLS)對象 
privatestaticfinal ThreadLocal sThreadLocal =new ThreadLocal(); 
// Looper內的消息隊列 
final MessageQueue mQueue; 
// 當前線程 
Thread mThread; 
// 。。。其他屬性 

// 每個Looper對象中有它的消息隊列，和它所屬的線程 
private Looper() { 
mQueue =new MessageQueue(); 
mRun =true; 
mThread = Thread.currentThread(); 
} 

// 我們調用該方法會在調用線程的TLS中創建Looper對象 
publicstaticfinalvoid prepare() { 
if (sThreadLocal.get() !=null) { 
// 試圖在有Looper的線程中再次創建Looper將拋出異常 
thrownew RuntimeException("Only one Looper may be created per thread"); 
} 
sThreadLocal.set(new Looper()); 
} 
// 其他方法 
} 

通過源碼，prepare()背後的工作方式一目瞭然，其核心就是將looper對象定義爲ThreadLocal。如果你還不清楚什麼是ThreadLocal，請參考《理解ThreadLocal》。

2）Looper.loop()

調用loop方法後，Looper線程就開始真正工作了，它不斷從自己的MQ中取出隊頭的消息(也叫任務)執行。其源碼分析如下：

複製代碼代碼如下:

publicstaticfinalvoid loop() { 
Looper me = myLooper(); //得到當前線程Looper 
MessageQueue queue = me.mQueue; //得到當前looper的MQ 

// 這兩行沒看懂= = 不過不影響理解 
Binder.clearCallingIdentity(); 
finallong ident = Binder.clearCallingIdentity(); 
// 開始循環 
while (true) { 
Message msg = queue.next(); // 取出message 
if (msg !=null) { 
if (msg.target ==null) { 
// message沒有target爲結束信號，退出循環 
return; 
} 
// 日誌。。。 
if (me.mLogging!=null) me.mLogging.println( 
">>>>> Dispatching to "+ msg.target +"" 
+ msg.callback +": "+ msg.what 
); 
// 非常重要！將真正的處理工作交給message的target，即後面要講的handler 
msg.target.dispatchMessage(msg); 
// 還是日誌。。。 
if (me.mLogging!=null) me.mLogging.println( 
"<<<<< Finished to "+ msg.target +"" 
+ msg.callback); 

// 下面沒看懂，同樣不影響理解 
finallong newIdent = Binder.clearCallingIdentity(); 
if (ident != newIdent) { 
Log.wtf("Looper", "Thread identity changed from 0x" 
+ Long.toHexString(ident) +" to 0x" 
+ Long.toHexString(newIdent) +" while dispatching to " 
+ msg.target.getClass().getName() +"" 
+ msg.callback +" what="+ msg.what); 
} 
// 回收message資源 
msg.recycle(); 
} 
} 
} 

除了prepare()和loop()方法，Looper類還提供了一些有用的方法，比如

Looper.myLooper()得到當前線程looper對象：

複製代碼代碼如下:

publicstaticfinal Looper myLooper() { // 在任意線程調用Looper.myLooper()返回的都是那個線程的looperreturn (Looper)sThreadLocal.get(); }

getThread()得到looper對象所屬線程：

複製代碼代碼如下:

public Thread getThread() { return mThread; }

quit()方法結束looper循環：

複製代碼代碼如下:

publicvoid quit() { 
// 創建一個空的message，它的target爲NULL，表示結束循環消息 
Message msg = Message.obtain(); 
// 發出消息 
mQueue.enqueueMessage(msg, 0); 
} 

到此爲止，你應該對Looper有了基本的瞭解，總結幾點：

1.每個線程有且最多只能有一個Looper對象，它是一個ThreadLocal

2.Looper內部有一個消息隊列，loop()方法調用後線程開始不斷從隊列中取出消息執行

3.Looper使一個線程變成Looper線程。

那麼，我們如何往MQ上添加消息呢？下面有請Handler！（掌聲~~~）

異步處理大師 Handler

什麼是handler？handler扮演了往MQ上添加消息和處理消息的角色（只處理由自己發出的消息），即通知MQ它要執行一個任務(sendMessage)，並在loop到自己的時候執行該任務(handleMessage)，整個過程是異步的。handler創建時會關聯一個looper，默認的構造方法將關聯當前線程的looper，不過這也是可以set的。默認的構造方法：

複製代碼代碼如下:

publicclass handler { 

final MessageQueue mQueue; // 關聯的MQ 
final Looper mLooper; // 關聯的looper 
final Callback mCallback; 
// 其他屬性 

public Handler() { 
// 沒看懂，直接略過，，， 
if (FIND_POTENTIAL_LEAKS) { 
final Class<?extends Handler> klass = getClass(); 
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) && 
(klass.getModifiers() & Modifier.STATIC) ==0) { 
Log.w(TAG, "The following Handler class should be static or leaks might occur: "+ 
klass.getCanonicalName()); 
} 
} 
// 默認將關聯當前線程的looper 
mLooper = Looper.myLooper(); 
// looper不能爲空，即該默認的構造方法只能在looper線程中使用 
if (mLooper ==null) { 
thrownew RuntimeException( 
"Can't create handler inside thread that has not called Looper.prepare()"); 
} 
// 重要！！！直接把關聯looper的MQ作爲自己的MQ，因此它的消息將發送到關聯looper的MQ上 
mQueue = mLooper.mQueue; 
mCallback =null; 
} 

// 其他方法 
} 

下面我們就可以爲之前的LooperThread類加入Handler：

複製代碼代碼如下:

publicclass LooperThread extends Thread { 
private Handler handler1; 
private Handler handler2; 

@Override 
publicvoid run() { 
// 將當前線程初始化爲Looper線程 
Looper.prepare(); 

// 實例化兩個handler 
handler1 =new Handler(); 
handler2 =new Handler(); 

// 開始循環處理消息隊列 
Looper.loop(); 
} 
} 

加入handler後的效果如下圖：

可以看到，一個線程可以有多個Handler，但是只能有一個Looper！

Handler發送消息

有了handler之後，我們就可以使用 post(Runnable), postAtTime(Runnable, long), postDelayed(Runnable, long), sendEmptyMessage(int), sendMessage(Message), sendMessageAtTime(Message, long)和 sendMessageDelayed(Message, long)這些方法向MQ上發送消息了。光看這些API你可能會覺得handler能發兩種消息，一種是Runnable對象，一種是message對象，這是直觀的理解，但其實post發出的Runnable對象最後都被封裝成message對象了，見源碼：

複製代碼代碼如下:

// 此方法用於向關聯的MQ上發送Runnable對象，它的run方法將在handler關聯的looper線程中執行 
publicfinalboolean post(Runnable r) 
{ 
// 注意getPostMessage(r)將runnable封裝成message 
return sendMessageDelayed(getPostMessage(r), 0); 
} 

privatefinal Message getPostMessage(Runnable r) { 
Message m = Message.obtain(); //得到空的message 
m.callback = r; //將runnable設爲message的callback， 
return m; 
} 

publicboolean sendMessageAtTime(Message msg, long uptimeMillis) 
{ 
boolean sent =false; 
MessageQueue queue = mQueue; 
if (queue !=null) { 
msg.target =this; // message的target必須設爲該handler！ 
sent = queue.enqueueMessage(msg, uptimeMillis); 
} 
else { 
RuntimeException e =new RuntimeException( 
this+" sendMessageAtTime() called with no mQueue"); 
Log.w("Looper", e.getMessage(), e); 
} 
return sent; 
} 

其他方法就不羅列了，總之通過handler發出的message有如下特點：

1.message.target爲該handler對象，這確保了looper執行到該message時能找到處理它的handler，即loop()方法中的關鍵代碼

複製代碼代碼如下:

msg.target.dispatchMessage(msg);

2.post發出的message，其callback爲Runnable對象

Handler處理消息

說完了消息的發送，再來看下handler如何處理消息。消息的處理是通過核心方法dispatchMessage(Message msg)與鉤子方法handleMessage(Message msg)完成的，見源碼

複製代碼代碼如下:

// 處理消息，該方法由looper調用 
publicvoid dispatchMessage(Message msg) { 
if (msg.callback !=null) { 
// 如果message設置了callback，即runnable消息，處理callback！ 
handleCallback(msg); 
} else { 
// 如果handler本身設置了callback，則執行callback 
if (mCallback !=null) { 
/* 這種方法允許讓activity等來實現Handler.Callback接口，避免了自己編寫handler重寫handleMessage方法。見http://alex-yang-xiansoftware-com.iteye.com/blog/850865 */ 
if (mCallback.handleMessage(msg)) { 
return; 
} 
} 
// 如果message沒有callback，則調用handler的鉤子方法handleMessage 
handleMessage(msg); 
} 
} 

// 處理runnable消息 
privatefinalvoid handleCallback(Message message) { 
message.callback.run(); //直接調用run方法！ 
} 
// 由子類實現的鉤子方法 
publicvoid handleMessage(Message msg) { 
} 

可以看到，除了handleMessage(Message msg)和Runnable對象的run方法由開發者實現外（實現具體邏輯），handler的內部工作機制對開發者是透明的。這正是handler API設計的精妙之處！

Handler的用處

我在小標題中將handler描述爲“異步處理大師”，這歸功於Handler擁有下面兩個重要的特點：

1.handler可以在任意線程發送消息，這些消息會被添加到關聯的MQ上。

              

2.handler是在它關聯的looper線程中處理消息的。

這就解決了android最經典的不能在其他非主線程中更新UI的問題。android的主線程也是一個looper線程(looper 在android中運用很廣)，我們在其中創建的handler默認將關聯主線程MQ。因此，利用handler的一個solution就是在 activity中創建handler並將其引用傳遞給worker thread，worker thread執行完任務後使用handler發送消息通知activity更新UI。(過程如圖)

下面給出sample代碼，僅供參考：

複製代碼代碼如下:

publicclass TestDriverActivity extends Activity { 
private TextView textview; 

@Override 
protectedvoid onCreate(Bundle savedInstanceState) { 
super.onCreate(savedInstanceState); 
setContentView(R.layout.main); 
textview = (TextView) findViewById(R.id.textview); 
// 創建並啓動工作線程 
Thread workerThread =new Thread(new SampleTask(new MyHandler())); 
workerThread.start(); 
} 

publicvoid appendText(String msg) { 
textview.setText(textview.getText() +"\n"+ msg); 
} 

class MyHandler extends Handler { 
@Override 
publicvoid handleMessage(Message msg) { 
String result = msg.getData().getString("message"); 
// 更新UI 
appendText(result); 
} 
} 
} 

複製代碼代碼如下:

publicclass SampleTask implements Runnable { 
privatestaticfinal String TAG = SampleTask.class.getSimpleName(); 
Handler handler; 

public SampleTask(Handler handler) { 
super(); 
this.handler = handler; 
} 

@Override 
publicvoid run() { 
try { // 模擬執行某項任務，下載等 
Thread.sleep(5000); 
// 任務完成後通知activity更新UI 
Message msg = prepareMessage("task completed!"); 
// message將被添加到主線程的MQ中 
handler.sendMessage(msg); 
} catch (InterruptedException e) { 
Log.d(TAG, "interrupted!"); 
} 

} 

private Message prepareMessage(String str) { 
Message result = handler.obtainMessage(); 
Bundle data =new Bundle(); 
data.putString("message", str); 
result.setData(data); 
return result; 
} 

} 

當然，handler能做的遠遠不僅如此，由於它能post Runnable對象，它還能與Looper配合實現經典的Pipeline Thread(流水線線程)模式。請參考此文《Android Guts: Intro to Loopers and Handlers》

封裝任務 Message

在整個消息處理機制中，message又叫task，封裝了任務攜帶的信息和處理該任務的handler。message的用法比較簡單，這裏不做總結了。但是有這麼幾點需要注意（待補充）：

1.儘管Message有public的默認構造方法，但是你應該通過Message.obtain()來從消息池中獲得空消息對象，以節省資源。

2.如果你的message只需要攜帶簡單的int信息，請優先使用Message.arg1和Message.arg2來傳遞信息，這比用Bundle更省內存

3.擅用message.what來標識信息，以便用不同方式處理message。