解析Android中Handler機制原理

Handler是Android中提供的一種異步回調機制，也可以理解為線程間的消息機制。為了避免ANR,我們通常會把一些耗時操作（比如：網絡請求、I/O操作、復雜計算等）放到子線程中去執行，而當子線程需要修改UI時則子線程需要通知主線程去完成修改UI的操作，則此時就需要我們使用Handler機制來完成子線程與主線程之間的通信。

1. Handler的一般使用步驟

在明確了Android中只有主線程能修改UI界面、子線程執行耗時操作的前提后，下面一起來學習下Handler的使用步驟。

1. 在主線程中創建Handler實例，并且重寫handlerMessage方法。

   private Handler handler = new Handler(){
   @Override
   public void handleMessage(Message msg) {
       switch (msg.what) {
           case 1:
               //執行相關修改UI的操作
               break;
           }
       }
   };

2. 子線程中獲取Handler對象，在需要執行更新UI操作的地方使用handler發送消息

   Message msg = Message.obtain();
   msg.obj = "content";
   msg.what = 1;
   //發送消息給Handler
   handler.sendMessage(msg);   

3. 在handlerMessage方法中的Switch里面，根據case下不同的常量執行相關操作

以上只是Handler的一種使用方式，由于本文的重點是探究Handlerde原理，故其他使用方式這里不重點介紹。

2. 重要類的職責

在深入了解Handler機制原理之前，我們應該明確在Handler機制中幾個重要類的職責。

• Handler：負責發送處理消息
• MessageQueue：消息隊列，負責存儲消息
• Message: 具體發送的消息
• Looper: 負責循環取出消息給Handler處理
• ThreadLocal: 用于線程間的數據隔離，在每個線程中存放各自對應的Looper

3. Handler機制原理

• 每個Handler都會關聯一個消息隊列，消息隊列又是封裝在Looper對象中，而每個Looper又會關聯一個線程。這樣Handler、消息隊列、線程三者就關聯上了。

• Handler是一個消息處理器，將消息發送給消息隊列，然后再由對應的線程從消息隊列中逐個取出，并執行。

• 默認情況下，消息隊列只有一個，也就是主線程的消息隊列，該消息隊列通過Looper.prepareMainLooper()方法創建，最后執行Looper.loop()來循環啟動消息。

以上敘述可能有點空洞，下面我們結合源碼一起來理解：

3.1 Handler是如何關聯消息隊列和線程的？

我們首先看Handler默認的構造函數：

     public Handler(Callback callback, boolean async) {
    //代碼省略
    mLooper = Looper.myLooper();//獲取Looper
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
    }
        mQueue = mLooper.mQueue;//通過Looper對象獲取消息隊列
        mCallback = callback;
        mAsynchronous = async;
    }

    //獲取Looper對象
    public final Looper getLooper() {
        return mLooper;
     }

從Handler的構造函數中我們可以發現，Handler在初始化的同時會通過Looper.getLooper()獲取一個Looper對象，并與Looper進行關聯，然后通過Looper對象獲取消息隊列。那我們繼續深入到Looper源碼中去看Looper.getLooper()是如何實現的。

    //初始化當前線程Looper
    public static void prepareMainLooper() {
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        sMainLooper = myLooper();
        }
     }

    //為當前線程設置一個Looper
    private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
         sThreadLocal.set(new Looper(quitAllowed));
     }

從上面的程序可以看出通過prepareMainLooper()，然后調用 prepare(boolean quitAllowed)方法創建了一個Looper對象，并通過sThreadLocal.set(new Looper(quitAllowed))方法將該對象設置給了sThreadLocal。

    //通過ThreadLocal獲取Looper
    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
     }

通過Looper中的預備工作，sThreadLocal中已經存儲了一個Looper對象，然后myLooper()方法通過sThreadLocal.get()方法獲取到了Looper。那么消息隊列就與線程關聯上了，所以各個線程只能訪問自己的消息隊列。

綜上所述，我們可以發現消息隊列通過Looper與線程關聯上了，而Looper又與Handler是關聯的，所以Handler就跟線程、線程的消息隊列關聯上了。

3.2 如何執行消息循環？

在創建Looper對象后，通過Handler發來的消息放在消息隊列中后是如何被處理的呢？這就涉及到了消息循環，消息循環是通過Looper.loop()方法來建立的。源代碼如下：

    //執行消息循環
    public static void loop() {
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;//獲取消息隊列
    //代碼省略
    for (;;) {//死循環
        Message msg = queue.next(); // 獲取消息
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
        //代碼省略
        try {
            msg.target.dispatchMessage(msg);//分發消息
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
        //代碼省略
        msg.recycleUnchecked();//消息回收
         }
    }   

從源碼中我們可以看出，loop()方法實質上就是通過一個死循環不斷的從消息隊列中獲取消息，然后又不斷的處理消息的過程。

3.3 消息處理機制

msg.target.dispatchMessage(msg);//分發消息

我們從loop中的 dispatchMessage()方法入手，看看誰是該方法的調用者，深入Message源碼中看看target的具體類型：

    public final class Message implements Parcelable {
        //代碼省略

        /*package*/ int flags;
        /*package*/ long when;
        /*package*/ Bundle data;
        /*package*/ Handler target;
        /*package*/ Runnable callback;
        /*package*/ Message next;

        //代碼省略
    }

從源碼中我們可以看到其實target就是Handler類型。所以Handler是將消息發送到消息隊列暫時存儲下，然后又將消息發送給Handler自身去處理。那我們繼續到Handler源碼中去看看Handler是如何處理消息的：

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

</br>

private static void handleCallback(Message message) {
    message.callback.run();
}

</br>

/**
 * Subclasses must implement this to receive messages.
 * 消息處理方法為一個空方法，由子類去實現
 */
public void handleMessage(Message msg) {
}

從上面的源碼中可以看出，dispatchMessage(Message msg)只負責分發Message。從Message源碼中我么可以知道callback為Runnable類型，如果callback不為空，則執行 handleCallback方法來處理，而該方法又會調用callback.run()；如果如果callback為空，則調用handleMessage來處理消息，而該方法又為空，所以我們會在子類中重寫該方法，并將修改UI的代碼寫在里面。之所以會出現這兩種情況，是因為Handler發送消息有兩種形式：

• 在本文的一般使用步驟中，我使用的是sendMessage(msg)發送消息，此時callback就為空。
• 當使用post發送消息時，callback就不為空。

以上就是Handler機制的原理，大致可以總結為：在子線程中Handler將消息發送到MessageQueue中，然后Looper不斷的從MessageQueue中讀取消息，并調用Handler的dispatchMessage發送消息，最后再Handler來處理消息。為了更好的幫助大家一起理解，我畫了一個Handler機制的原理圖：

關于Handler機制補充如下幾點：

• Handler創建消息時用到了消息池，在創建消息時會先從消息池中去查詢是否有消息對象，如果有，則直接使用消息池中的對象，如果沒有，則創建一個新的消息對象。
• 使用ThreadLocal的目的是保證每一個線程只創建唯一一個Looper。之后其他Handler初始化的時候直接獲取第一個Handler創建的Looper