本文來一起討論下Android的handler機(jī)制。

相信寫過android的童鞋，一定對handler很熟悉。因?yàn)槭褂妙l率實(shí)在太高了。尤其是在非ui線程，想要刷新ui控件的時候。因?yàn)閡i控件的刷新只能在主線程做，但是我們可能有在非ui線程卻需要更新ui的需求，比如在一個后臺線程下載了圖片需要更新到ui上，這時候就需要主線程handler來發(fā)送更新的message。

handler的使用如此頻繁，我們有必要知道其內(nèi)部是如何工作的。

• 一句話概括
• handler thread
• handler
  • 發(fā)送什么
  • 觸發(fā)的線程
  • 創(chuàng)建handler
  • runnable的封裝
  • 如何處理消息
• message
  • 如何產(chǎn)生消息
  • 發(fā)送時機(jī)
• Looper
  • 創(chuàng)建looper
  • 派發(fā)消息
  • 例子
• 總結(jié)

一句話概括

handler, looper, message的組合，能夠做什么工作?簡單地說，就一句話：在一個線程里，指定在另一個線程里，執(zhí)行一個任務(wù)。

handler thread

什么是handler thread。當(dāng)一個線程，創(chuàng)建了looper，looper里面擁有message queue，創(chuàng)建了handler，那么，這個線程就是一個handler thread。

handler thread的作用就是，讓其他的線程指定handler thread去執(zhí)行一個任務(wù)。比如ui線程就是一個handler thread。我們可以在普通線程中，指定讓ui線程去更新ui。

handler

handler有兩個工作，一是發(fā)送任務(wù)或者消息;二是處理消息或者執(zhí)行任務(wù)。

發(fā)送什么

handler可以發(fā)送什么

handler和message queue密切聯(lián)系，直覺上handler會發(fā)送消息到message queue。其實(shí)不僅如此，handler既能發(fā)送message，也能發(fā)送runnbale。換句話說，message queue不只是裝message的queue(其實(shí)是一個單鏈表)，而且還能裝runnable。

觸發(fā)的線程

handler發(fā)送消息或者任務(wù)，一般是在其他線程發(fā)送的，即發(fā)送消息時所在的線程，并不是創(chuàng)建handler的線程(當(dāng)然，也可以在創(chuàng)建handler的線程發(fā)消息，等于自己發(fā)給自己)。

而handler處理消息或執(zhí)行任務(wù)，則是在創(chuàng)建自己的線程中執(zhí)行的。

創(chuàng)建handler

handler和looper并不是ui線程獨(dú)有的。任何一個普通的線程，都可以創(chuàng)建自己的looper，創(chuàng)建自己的handler。

但是有一點(diǎn)需要注意，創(chuàng)建handler前，必須先創(chuàng)建looper。

如果不創(chuàng)建looper，直接new一個handler，比如

new Thread(new Runnable(){ 
    public void run() { 
        Handler handler = new Handler(); 
    } 
}).start();  

運(yùn)行時，會直接報錯：

Can’t create handler inside thread that has not called Looper.prepare() 

來看看handler的構(gòu)造函數(shù)

public Handler(Callback callback, boolean async) { 
        ... 
        mLooper = Looper.myLooper();  // Looper.myLooper用于獲取當(dāng)前線程的looper 
        if (mLooper == null) { 
            throw new RuntimeException( 
                "Can't create handler inside thread that has not called Looper.prepare()"); 
        } 
        mQueue = mLooper.mQueue; 
        ... 
    }  

handler發(fā)送消息到message queue，所以，構(gòu)造一個handler的時候必須知道m(xù)essage queue，才能確定把消息發(fā)送到哪里。

而message queue是由looper來管理的，因此順序上，必須先創(chuàng)建了looper，才能創(chuàng)建handler。

創(chuàng)建線程的Looper，

Looper.prepare(); 

所以，創(chuàng)建一個handler的正確寫法是：

new Thread(new Runnable(){ 
    public void run() { 
        Looper.prepare(); 
        Handler handler = new Handler(); 
    } 
}).start();  

可能有同學(xué)會覺得奇怪，平時用new Handler() 的時候沒有先調(diào)用Looper.prepare()也一樣可以用呀?那是因?yàn)?，handler是在主線程創(chuàng)建的。

// ActivityThread.java 
public static void main(String[] args) { 
    ... 
    Looper.prepareMainLooper(); 
    ... 
}  

主線程在啟動的時候，就會調(diào)用Looper.prepareMainLooper() 創(chuàng)建looper，所以，我們可以在主線程直接創(chuàng)建handler，不需要手動先創(chuàng)建looper。

runnable的封裝

可能大家會覺得奇怪，message queue應(yīng)該裝的是message，那么handler.post(runnable)，runnable跑哪里去了呢?

runnable其實(shí)也是發(fā)送給了message queue，只不過在發(fā)送前，先對runnable進(jìn)行了封裝。

public final boolean post(Runnable r){ 
   return  sendMessageDelayed(getPostMessage(r), 0); 
} 
 
private static Message getPostMessage(Runnable r) { 
    Message m = Message.obtain(); 
    m.callback = r; 
    return m; 
}  

用getPostMessage 把runnable包裝成一個message，message的callback就是runnable。因此，分辨一個message是不是runnable，其實(shí)只要看message的callback是否為空，如果為空，就是普通的message，否則，就是一個runnbale。

如何處理消息

看下dispathMessage

public void dispatchMessage(Message msg) { 
    if (msg.callback != null) { 
         handleCallback(msg);    // handler.post(runnable)時走這里 
     } else { 
         if (mCallback != null) { // handler = new Handler(callback)時走這里 
             if (mCallback.handleMessage(msg)) { 
                 return; 
             } 
         } 
         handleMessage(msg); // handler = new Handler()時走這里 
     } 
 }  

根據(jù)handler發(fā)送消息的類型，分成2種情況：

• handler發(fā)送了一個message到message queue
• handler發(fā)送了一個runnbale到message queue

根據(jù)前面提到的，message.callback其實(shí)就是對runnable的封裝，所以，如果handler是發(fā)送了一個runnable到message queue，那么就會執(zhí)行這個runnable。

如果handler是發(fā)送了一個message到message queue，那么又細(xì)分為2種情況

• handler創(chuàng)建時設(shè)置了callback, 即handler = new Handler(callback);
• handler創(chuàng)建時未設(shè)置callback，即handler = new Handler();

如果設(shè)置了callback，那么message會先被callback處理。

如果callback返回true，說明處理完成，不會再傳給handler.handleMessage了。

如果callback返回false，說明處理未完成，會再把message傳給handler.handleMessage繼續(xù)處理。

如果未設(shè)置callback，message會直接傳給handler.handleMessage處理。

message

如何產(chǎn)生消息

消息如何產(chǎn)生

message可以由構(gòu)造函數(shù)生成。更多的時候，是從可回收的消息對象池里面直接獲取的，提供性能。從消息對象池獲取一個消息的方式是Message.obtain()，也可以用Handler.obtainMessage()。

另外，不產(chǎn)生消息，也可以發(fā)送消息。好繞口，啥意思?handler.sendEmptyMessage()，可以發(fā)送一個空消息到message queue，不需要構(gòu)造一個message對象。

發(fā)送時機(jī)

消息什么時候發(fā)送

消息的處理時機(jī)還是由handler來決定(感覺handler管的好寬==)。

handler.sendMessage，把message放到message queue的尾部排隊(duì)，looper從前往后一個一個取消息。handler.sendMessageAtFrontOfQueue，把message放到message queue的頭部，消息可以馬上被處理。

handler.sendMessageAtTime，不馬上發(fā)送消息到message queue，而是在指定的時間點(diǎn)發(fā)送。

handler.sendMessageDelayed，不馬上發(fā)送消息到message queue，而是在指定的時延后再發(fā)送。

Looper

創(chuàng)建looper

前面提到，looper就像一個發(fā)送機(jī)一樣，會從message queue中取出消息，然后派發(fā)給handler處理。因此，要知道m(xù)essage應(yīng)該發(fā)送到哪個handler，必須先創(chuàng)建looper。

創(chuàng)建looper的方法

Loop.prepare(); 

派發(fā)消息

通過looper.loop()，looper會不斷從message queue取消息，并派發(fā)出去。

looper怎么知道m(xù)essage應(yīng)該派發(fā)給哪一個handler呢?

一起看看loop方法

public static void loop() { 
    ... 
    for (;;) { 
        Message msg = queue.next(); // might block 
        if (msg == null) { 
            // No message indicates that the message queue is quitting. 
            return; 
        } 
        ... 
        msg.target.dispatchMessage(msg); 
        ... 
    } 
}  

每個msg都有一個target屬性，這個target就是發(fā)送消息的handler，派發(fā)message，就是派發(fā)給msg.target對象。

loop方法并不是無限循環(huán)的，一旦message queue為空，就會結(jié)束，以免長期占用cpu資源。

例子

下圖中，線程A是一個handler thread。現(xiàn)在線程B想讓線程A處理一個消息message 5。于是，線程B拿到線程A的handler引用，然后調(diào)用handler的sendMessage。

message 5被發(fā)送到線程A的message queue。

線程A怎么去處理這個消息呢?使用looper.loop方法，每次會從message queue取出一條消息，當(dāng)取到message 5，說明message 5即將被處理。 

真正的消息處理邏輯，是在handler的handleMessage里面自定義的(或者runnable，callback，這里以handleMessage為例)。

looper取到message 5，通過message 5的target屬性，知道目標(biāo)handler，然后把消息發(fā)送給handler進(jìn)行處理。

總結(jié)

handler不是獨(dú)立存在的，一個handler，一定有一個專屬的線程，一個消息隊(duì)列，和一個looper與之關(guān)聯(lián)。

這幾個角色是如何協(xié)同工作的呢?簡單概括為下面四個步驟：

1. handler發(fā)送消息到message queue，這個消息可能是一個message，可能是一個runnable
2. looper負(fù)責(zé)從message queue取消息
3. looper把消息dispatch給handler
4. handler處理消息(handleMessage或者執(zhí)行runnable)

handler和looper的關(guān)系有點(diǎn)類似于生產(chǎn)者和消費(fèi)者的關(guān)系，handler是生產(chǎn)者，生產(chǎn)消息然后添加到message queue;looper是消費(fèi)者，從message queue取消息。