本文來一起討論下Android的handler機制。

相信寫過android的童鞋，一定對handler很熟悉。因為使用頻率實在太高了。尤其是在非ui線程，想要刷新ui控件的時候。因為ui控件的刷新只能在主線程做，但是我們可能有在非ui線程卻需要更新ui的需求，比如在一個后臺線程下載了圖片需要更新到ui上，這時候就需要主線程handler來發送更新的message。

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

• 一句話概括
• handler thread
• handler
  • 發送什么
  • 觸發的線程
  • 創建handler
  • runnable的封裝
  • 如何處理消息
• message
  • 如何產生消息
  • 發送時機
• Looper
  • 創建looper
  • 派發消息
  • 例子
• 總結

一句話概括

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

handler thread

什么是handler thread。當一個線程，創建了looper，looper里面擁有message queue，創建了handler，那么，這個線程就是一個handler thread。

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

handler

handler有兩個工作，一是發送任務或者消息;二是處理消息或者執行任務。

發送什么

handler可以發送什么

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

觸發的線程

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

而handler處理消息或執行任務，則是在創建自己的線程中執行的。

創建handler

handler和looper并不是ui線程獨有的。任何一個普通的線程，都可以創建自己的looper，創建自己的handler。

但是有一點需要注意，創建handler前，必須先創建looper。

如果不創建looper，直接new一個handler，比如

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

運行時，會直接報錯：

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

來看看handler的構造函數

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

handler發送消息到message queue，所以，構造一個handler的時候必須知道message queue，才能確定把消息發送到哪里。

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

創建線程的Looper，

Looper.prepare(); 

所以，創建一個handler的正確寫法是：

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

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

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

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

runnable的封裝

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

runnable其實也是發送給了message queue，只不過在發送前，先對runnable進行了封裝。

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，其實只要看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()時走這里 
     } 
 }  

根據handler發送消息的類型，分成2種情況：

• handler發送了一個message到message queue
• handler發送了一個runnbale到message queue

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

如果handler是發送了一個message到message queue，那么又細分為2種情況

• handler創建時設置了callback, 即handler = new Handler(callback);
• handler創建時未設置callback，即handler = new Handler();

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

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

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

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

message

如何產生消息

消息如何產生

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

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

發送時機

消息什么時候發送

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

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

handler.sendMessageAtTime，不馬上發送消息到message queue，而是在指定的時間點發送。

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

Looper

創建looper

前面提到，looper就像一個發送機一樣，會從message queue中取出消息，然后派發給handler處理。因此，要知道message應該發送到哪個handler，必須先創建looper。

創建looper的方法

Loop.prepare(); 

派發消息

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

looper怎么知道message應該派發給哪一個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就是發送消息的handler，派發message，就是派發給msg.target對象。

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

例子

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

message 5被發送到線程A的message queue。

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

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

looper取到message 5，通過message 5的target屬性，知道目標handler，然后把消息發送給handler進行處理。

總結

handler不是獨立存在的，一個handler，一定有一個專屬的線程，一個消息隊列，和一個looper與之關聯。

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

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

handler和looper的關系有點類似于生產者和消費者的關系，handler是生產者，生產消息然后添加到message queue;looper是消費者，從message queue取消息。