Android的訊息處理機制：Message、Handlerhe和Looper原始碼解析
android的訊息處理有三個核心類：Looper,Handler和Message。其實還有一個Message Queue（訊息佇列），但是MQ被封裝到Looper裡面了，我們不會直接與MQ打交道，因此我沒將其作為核心類。下面一一介紹：
執行緒的魔法師 LooperLooper的字面意思是“迴圈者”，它被設計用來使一個普通執行緒變成Looper執行緒。所謂Looper執行緒就是迴圈工作的執行緒。在程式開發中（尤其是GUI開發中），我們經常會需要一個執行緒不斷迴圈，一旦有新任務則執行，執行完繼續等待下一個任務，這就是Looper執行緒。使用Looper類建立Looper執行緒很簡單：
View Code@Override
public voidrun() {
// 將當前執行緒初始化為Looper執行緒Looper.prepare();
// ...其他處理，如例項化handler
// 開始迴圈處理訊息佇列Looper.loop();
}
} 複製程式碼
通過上面兩行核心程式碼，你的執行緒就升級為Looper執行緒了！！！是不是很神奇？讓我們放慢鏡頭，看看這兩行程式碼各自做了什麼。
1)Looper.prepare()
通過上圖可以看到，現在你的執行緒中有一個Looper物件，它的內部維護了一個訊息佇列MQ。注意，一個Thread只能有一個Looper物件
View Code
public
class Looper {// 每個執行緒中的Looper物件其實是一個ThreadLocal，即執行緒本地儲存(TLS)物件private staticfinalThreadLocal sThreadLocal=newThreadLocal();
// Looper內的訊息佇列final MessageQueue mQueue;
// 當前執行緒Thread mThread;
// 。。。其他屬性
// 每個Looper物件中有它的訊息佇列，和它所屬的執行緒private Looper() {
mQueue = newMessageQueue();
mRun
mThread = Thread.currentThread();
}
// 我們呼叫該方法會在呼叫執行緒的TLS中建立Looper物件public staticfinalvoidprepare() {
if (sThreadLocal.get()!=null) {
// 試圖在有Looper的執行緒中再次建立Looper將丟擲異常throw newRuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper());
}
// 其他方法} 複製程式碼
通過原始碼，prepare()背後的工作方式一目瞭然，其核心就是將looper物件定義為ThreadLocal。如果你還不清楚什麼是ThreadLocal，請參考《理解ThreadLocal》。
2）Looper.loop()
呼叫loop方法後，Looper執行緒就開始真正工作了，它不斷從自己的MQ中取出隊頭的訊息(也叫任務)執行。其原始碼分析如下：
View Code
public
static final
void loop() {Looper me = myLooper(); //得到當前執行緒LooperMessageQueue queue = me.mQueue; //得到當前looper的MQ
// 這兩行沒看懂= = 不過不影響理解Binder.clearCallingIdentity();
final longident=Binder.clearCallingIdentity();
// 開始迴圈while (true) {
Message msg = queue.next(); // 取出messageif (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，即後面要講的handlermsg.target.dispatchMessage(msg);
// 還是日誌。。。if (me.mLogging!=null) me.mLogging.println(
"<<<<< Finished to"+msg.target+" "+ msg.callback);
// 下面沒看懂，同樣不影響理解final longnewIdent=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物件：
View Code
public
static final
Looper myLooper() {// 在任意執行緒呼叫Looper.myLooper()返回的都是那個執行緒的looperreturn (Looper)sThreadLocal.get();
} 複製程式碼
getThread()得到looper物件所屬執行緒：
View Code
public
Thread getThread() {return mThread;
} 複製程式碼
quit()方法結束looper迴圈：
View Code
public
void 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的。預設的構造方法：
View Code
public
class handler {final MessageQueue mQueue;//關聯的MQfinal Looper mLooper;//關聯的looperfinal Callback mCallback;
// 其他屬性public Handler() {
// 沒看懂，直接略過，，，if (FIND_POTENTIAL_LEAKS) {
final Class<?extendsHandler>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());
}
}
// 預設將關聯當前執行緒的loopermLooper =Looper.myLooper();
// looper不能為空，即該預設的構造方法只能在looper執行緒中使用if (mLooper==null) {
throw newRuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
// 重要！！！直接把關聯looper的MQ作為自己的MQ，因此它的訊息將傳送到關聯looper的MQ上mQueue =mLooper.mQueue;
mCallback = null;
}
// 其他方法} 複製程式碼
下面我們就可以為之前的LooperThread類加入Handler：
View Code
public
class LooperThread
extends Thread {private Handler handler1;
private Handler handler2;
@Override
public voidrun() {
// 將當前執行緒初始化為Looper執行緒Looper.prepare();
// 例項化兩個handlerhandler1 =newHandler();
handler2 = new Handler();
// 開始迴圈處理訊息佇列Looper.loop();
}
} 複製程式碼
加入handler後的效果如下圖：
可以看到，一個執行緒可以有多個Handler，但是隻能有一個Looper！
Handler傳送訊息
有了handler之後，我們就可以使用 這些方法向MQ上傳送訊息了。光看這些API你可能會覺得handler能發兩種訊息，一種是Runnable物件，一種是message物件，這是直觀的理解，但其實post發出的Runnable物件最後都被封裝成message物件了，見原始碼：
View Code
//
此方法用於向關聯的MQ上傳送Runnable物件，它的run方法將在handler關聯的looper執行緒中執行public finalbooleanpost(Runnable r){
// 注意getPostMessage(r)將runnable封裝成messagereturn sendMessageDelayed(getPostMessage(r),0);
}
private finalMessage getPostMessage(Runnable r) {
Message m = Message.obtain(); //得到空的messagem.callback = r; //將runnable設為message的callback，return m;
}
public booleansendMessageAtTime(Message msg,longuptimeMillis)
{
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(Messagemsg)與鉤子方法handleMessage(Message msg)完成的，見原始碼
View Code
//
處理訊息，該方法由looper呼叫public voiddispatchMessage(Message msg) {if (msg.callback!=null) {
// 如果message設定了callback，即runnable訊息，處理callback！handleCallback(msg);
} else {
// 如果handler本身設定了callback，則執行callbackif (mCallback!=null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
// 如果message沒有callback，則呼叫handler的鉤子方法handleMessagehandleMessage(msg);
}
}
// 處理runnable訊息private finalvoidhandleCallback(Message message) {
message.callback.run(); //直接呼叫run方法！}
// 由子類實現的鉤子方法public voidhandleMessage(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程式碼，僅供參考：
View Code
public
class TestDriverActivity
extends Activity {private TextView textview;
@Override
protected voidonCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
textview = (TextView) findViewById(R.id.textview);
// 建立並啟動工作執行緒Thread workerThread = new Thread(newSampleTask(newMyHandler()));
workerThread.start();
}
public voidappendText(String msg) {
textview.setText(textview.getText() + "\n"+msg);
}
class MyHandlerextendsHandler {
@Override
public voidhandleMessage(Message msg) {
String result = msg.getData().getString("message");
// 更新UIappendText(result);
}
}
} 複製程式碼
View Code
public
class SampleTask
implements Runnable {private staticfinalString TAG=SampleTask.class.getSimpleName();
Handler handler;
public SampleTask(Handler handler) {
super();
this.handler=handler;
}
@Override
public voidrun() {
try {//模擬執行某項任務，下載等Thread.sleep(5000);
// 任務完成後通知activity更新UIMessage 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(流水線執行緒)模式。
封裝任務 Message
在整個訊息處理機制中，message又叫task，封裝了任務攜帶的資訊和處理該任務的handler。message的用法比較簡單，這裡不做總結了。但是有這麼幾點需要注意（待補充）：
1.儘管Message有public的預設構造方法，但是你應該通過Message.obtain()來從訊息池中獲得空訊息物件，以節省資源。
2.如果你的message只需要攜帶簡單的int資訊，請優先使用Message.arg1和Message.arg2來傳遞資訊，這比用Bundle更省記憶體
3.擅用message.what來標識資訊，以便用不同方式處理message。
----------------------------------------------------------------------------------------