android的消息處理機制——Looper，Handler，Message

這篇文章有一半是copy別人的，站在巨人的肩膀上，我們才能看得更高更遠......

在開始討論android的消息處理機制前，先來談談一些基本相關的術語。

通信的同步（Synchronous）：指向客戶端發送請求後，必須要在服務端有回應後客戶端才繼續發送其它的請求，所以這時所有請求將會在服務端得到同步，直到服務端返回請求。

通信的異步（Asynchronous）：指客戶端在發送請求後，不必等待服務端的回應就可以發送下一個請求。

所謂同步調用，就是在一個函數或方法調用時，沒有得到結果之前，該調用就不返回，直到返回結果。異步調用和同步是相對的，在一個異步調用發起後，被調用者立即返回給調用者，但是調用者不能立刻得到結果，被調用都在實際處理這個調用的請求完成後，通過狀態、通知或回調等方式來通知調用者請求處理的結果。

android的消息處理有三個核心類：Looper,Handler和Message。其實還有一Message Queue（消息隊列），但是MQ被封裝到Looper裡面了，我們不會直接與MQ打交道，所以它不算是個核心類。

handler機制原理

在安卓中有4大組件:activity,service,contentprovider,broadcastreceiver,這4大組件都運行在主線,谷歌官方規定,安卓不能再主線程做耗時操作,負責會造成ANR,為了避免這種情況的出現,必須開線程處理耗時操作,但是安卓規定,子線程不能更新UI,所以安卓引入了Handler機制,

(因為安卓中的UI控件不是線程安全的,如果在多線程中,並發訪問可能會導致UI控件處於不可預期的狀態,(為啥系統不對UI控件的訪問加鎖機制,缺點有兩個1:加上鎖機制會讓UI訪問的邏輯變的復雜,其次鎖機制會降低UI訪問的效率,因為鎖機制會阻塞某些線程的執行,最簡單最高效就是采用單線程來處理,對於我們來說也不是很麻煩,只需要通過Handler切換一下UI訪問的執行線程即可))

Handler主要用於線程間的通信。

一個Handler允許發送和處理Message和Runable對象，UI主線程會自動分配一個Looper（消息輪詢器），每個Looper中封裝著MessageQueue（消息隊列），遵循先進先出原則。

Looper負責不斷的從自己的消息隊列裡取出隊頭的任務或消息執行。

一般是在子線程執行完耗時操作之後，通過Handler的sendMessage或post方法將Message和Runable對象傳遞給MessageQueue，而且在這些對象離開MessageQueue時，Handler負責執行他們（用到handleMessage方法，主要執行刷新UI的代碼）。
其中Message類就是定義了一個信息，這個信息中包含一個描述符和任意的數據對象，這個信息被用來傳遞給Handler.Message對象提供額外的兩個int域和一個Object域。

1. 消息類：Message類

android.os.Message的主要功能是進行消息的封裝，同時可以指定消息的操作形式，Message類定義的變量和常用方法如下：

（1）public int what：變量，用於定義此Message屬於何種操作

（2）public Object obj：變量，用於定義此Message傳遞的信息數據，通過它傳遞信息

（3）public int arg1：變量，傳遞一些整型數據時使用

（4）public int arg2：變量，傳遞一些整型數據時使用

（5）public Handler getTarget()：普通方法，取得操作此消息的Handler對象。

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

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

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

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

2. 消息通道：Looper

在使用Handler處理Message時，需要Looper（通道）來完成。在一個Activity中，系統會自動幫用戶啟動Looper對象，而在一個用戶自定義的類中，則需要用戶手工調用Looper類中的方法，然後才可以正常啟動Looper對象。Looper的字面意思是“循環者”，它被設計用來使一個普通線程變成Looper線程。所謂Looper線程就是循環工作的線程。在程序開發中（尤其是GUI開發中），我們經常會需要一個線程不斷循環，一旦有新任務則執行，執行完繼續等待下一個任務，這就是Looper線程。使用Looper類創建Looper線程很簡單：

publicclassLooperThreadextendsThread{
@Override
publicvoidrun(){
//將當前線程初始化為Looper線程
Looper.prepare();

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

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

通過上面兩行核心代碼，你的線程就升級為Looper線程了！那麼這兩行代碼都做了些什麼呢？

1)Looper.prepare()

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

publicclassLooper{
//每個線程中的Looper對象其實是一個ThreadLocal，即線程本地存儲(TLS)對象
privatestaticfinalThreadLocalsThreadLocal=newThreadLocal();
//Looper內的消息隊列
finalMessageQueuemQueue;
//當前線程
ThreadmThread;
//其他屬性
//每個Looper對象中有它的消息隊列，和它所屬的線程
privateLooper(){
mQueue=newMessageQueue();
mRun=true;
mThread=Thread.currentThread();
}
//我們調用該方法會在調用線程的TLS中創建Looper對象
publicstaticfinalvoidprepare(){
if(sThreadLocal.get()!=null){
//試圖在有Looper的線程中再次創建Looper將拋出異常
thrownewRuntimeException("OnlyoneLoopermaybecreatedperthread");
}
sThreadLocal.set(newLooper());
}
//其他方法
}

prepare()背後的工作方式一目了然，其核心就是將looper對象定義為ThreadLocal。

2）Looper.loop()

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

publicstaticfinalvoidloop(){
Looperme=myLooper();//得到當前線程Looper
MessageQueuequeue=me.mQueue;//得到當前looper的MQ

Binder.clearCallingIdentity();
finallongident=Binder.clearCallingIdentity();
//開始循環
while(true){
Messagemsg=queue.next();//取出message
if(msg!=null){
if(msg.target==null){
//message沒有target為結束信號，退出循環
return;
}
//日志
if(me.mLogging!=null)me.mLogging.println(
">>>>>Dispatchingto"+msg.target+""
+msg.callback+":"+msg.what
);
//非常重要！將真正的處理工作交給message的target，即後面要講的handler
msg.target.dispatchMessage(msg);
//日志
if(me.mLogging!=null)me.mLogging.println(
"<<<<

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

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

publicThreadgetThread(){
returnmThread;
}

quit()方法結束looper循環：

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

綜上，Looper有以下幾個要點：

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

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

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

那麼，我們如何操作Message Queue上的消息呢？這就是Handler的用處了

3. 消息操作類：Handler類

Message對象封裝了所有的消息，而這些消息的操作需要android.os.Handler類完成。什麼是handler？handler起到了處理MQ上的消息的作用（只處理由自己發出的消息），即通知MQ它要執行一個任務(sendMessage)，並在loop到自己的時候執行該任務(handleMessage)，整個過程是異步的。handler創建時會關聯一個looper，默認的構造方法將關聯當前線程的looper，不過這也是可以set的。默認的構造方法：

publicclasshandler{
finalMessageQueuemQueue;//關聯的MQ
finalLoopermLooper;//關聯的looper
finalCallbackmCallback;
//其他屬性
publicHandler(){
if(FIND_POTENTIAL_LEAKS){
finalClassklass=getClass();
if((klass.isAnonymousClass()||klass.isMemberClass()||klass.isLocalClass())&&
(klass.getModifiers()&Modifier.STATIC)==0){
Log.w(TAG,"ThefollowingHandlerclassshouldbestaticorleaksmightoccur:"+klass.getCanonicalName());
}
}
//默認將關聯當前線程的looper
mLooper=Looper.myLooper();
//looper不能為空，即該默認的構造方法只能在looper線程中使用
if(mLooper==null){
thrownewRuntimeException(
"Can'tcreatehandlerinsidethreadthathasnotcalledLooper.prepare()");
}
//重要！！！直接把關聯looper的MQ作為自己的MQ，因此它的消息將發送到關聯looper的MQ上
mQueue=mLooper.mQueue;
mCallback=null;
}

//其他方法
}

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

publicclassLooperThreadextendsThread{
privateHandlerhandler1;
privateHandlerhandler2;

@Override
publicvoidrun(){
//將當前線程初始化為Looper線程
Looper.prepare();

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

//開始循環處理消息隊列
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線程中執行
publicfinalbooleanpost(Runnabler)
{
//注意getPostMessage(r)將runnable封裝成message
returnsendMessageDelayed(getPostMessage(r),0);
}

privatefinalMessagegetPostMessage(Runnabler){
Messagem=Message.obtain();//得到空的message
m.callback=r;//將runnable設為message的callback，
returnm;
}

publicbooleansendMessageAtTime(Messagemsg,longuptimeMillis)
{
booleansent=false;
MessageQueuequeue=mQueue;
if(queue!=null){
msg.target=this;//message的target必須設為該handler！
sent=queue.enqueueMessage(msg,uptimeMillis);
}
else{
RuntimeExceptione=newRuntimeException(
this+"sendMessageAtTime()calledwithnomQueue");
Log.w("Looper",e.getMessage(),e);
}
returnsent;
}

通過handler發出的message有如下特點：

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

msg.target.dispatchMessage(msg);

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

Handler處理消息

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

完成的，見源碼

dispatchMessage(Messagemsg){
(msg.callback!=){
handleCallback(msg);
}{
(mCallback!=){

(mCallback.handleMessage(msg)){
;
}
}
handleMessage(msg);
}
}

handleCallback(Messagemessage){
message.callback.run();}
handleMessage(Messagemsg){
}

可以看到，除了handleMessage(Messagemsg)和Runnable對象的run方法由開發者實現外（實現具體邏輯），handler的內部工作機制對開發者是透明的。Handler擁有下面兩個重要的特點：

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

2)消息的處理是通過核心方法dispatchMessage(Messagemsg)與鉤子方法handleMessage(Messagemsg)完成的，handler是在它關聯的looper線程中處理消息的。

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

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

TestDriverActivityActivity{
TextViewtextview;

@Override
onCreate(BundlesavedInstanceState){
.onCreate(savedInstanceState);
setContentView(R.layout.main);
textview=(TextView)findViewById(R.id.textview);
ThreadworkerThread=Thread(SampleTask(MyHandler()));
workerThread.start();
}

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

MyHandlerHandler{
@Override
handleMessage(Messagemsg){
Stringresult=msg.getData().getString("message");
appendText(result);
}
}
}

SampleTaskRunnable{
StringTAG=SampleTask..getSimpleName();
Handlerhandler;

SampleTask(Handlerhandler){
();
.handler=handler;
}

@Override
run(){
{Thread.sleep(5000);
Messagemsg=prepareMessage("taskcompleted!");
handler.sendMessage(msg);
}(InterruptedExceptione){
Log.d(TAG,"interrupted!");
}

}

MessageprepareMessage(Stringstr){
Messageresult=handler.obtainMessage();
Bundledata=Bundle();
data.putString("message",str);
result.setData(data);
result;
}

}