解析Android中Handler機(jī)制原理

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

1. Handler的一般使用步驟

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

1. 在主線程中創(chuàng)建Handler實(shí)例，并且重寫handlerMessage方法。

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

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

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

3. 在handlerMessage方法中的Switch里面，根據(jù)case下不同的常量執(zhí)行相關(guān)操作

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

2. 重要類的職責(zé)

在深入了解Handler機(jī)制原理之前，我們應(yīng)該明確在Handler機(jī)制中幾個(gè)重要類的職責(zé)。

• Handler：負(fù)責(zé)發(fā)送處理消息
• MessageQueue：消息隊(duì)列，負(fù)責(zé)存儲(chǔ)消息
• Message: 具體發(fā)送的消息
• Looper: 負(fù)責(zé)循環(huán)取出消息給Handler處理
• ThreadLocal: 用于線程間的數(shù)據(jù)隔離，在每個(gè)線程中存放各自對應(yīng)的Looper

3. Handler機(jī)制原理

• 每個(gè)Handler都會(huì)關(guān)聯(lián)一個(gè)消息隊(duì)列，消息隊(duì)列又是封裝在Looper對象中，而每個(gè)Looper又會(huì)關(guān)聯(lián)一個(gè)線程。這樣Handler、消息隊(duì)列、線程三者就關(guān)聯(lián)上了。

• Handler是一個(gè)消息處理器，將消息發(fā)送給消息隊(duì)列，然后再由對應(yīng)的線程從消息隊(duì)列中逐個(gè)取出，并執(zhí)行。

• 默認(rèn)情況下，消息隊(duì)列只有一個(gè)，也就是主線程的消息隊(duì)列，該消息隊(duì)列通過Looper.prepareMainLooper()方法創(chuàng)建，最后執(zhí)行Looper.loop()來循環(huán)啟動(dòng)消息。

以上敘述可能有點(diǎn)空洞，下面我們結(jié)合源碼一起來理解：

3.1 Handler是如何關(guān)聯(lián)消息隊(duì)列和線程的？

我們首先看Handler默認(rèn)的構(gòu)造函數(shù)：

     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對象獲取消息隊(duì)列
        mCallback = callback;
        mAsynchronous = async;
    }

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

從Handler的構(gòu)造函數(shù)中我們可以發(fā)現(xiàn)，Handler在初始化的同時(shí)會(huì)通過Looper.getLooper()獲取一個(gè)Looper對象，并與Looper進(jìn)行關(guān)聯(lián)，然后通過Looper對象獲取消息隊(duì)列。那我們繼續(xù)深入到Looper源碼中去看Looper.getLooper()是如何實(shí)現(xiàn)的。

    //初始化當(dāng)前線程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();
        }
     }

    //為當(dāng)前線程設(shè)置一個(gè)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()，然后調(diào)用 prepare(boolean quitAllowed)方法創(chuàng)建了一個(gè)Looper對象，并通過sThreadLocal.set(new Looper(quitAllowed))方法將該對象設(shè)置給了sThreadLocal。

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

通過Looper中的預(yù)備工作，sThreadLocal中已經(jīng)存儲(chǔ)了一個(gè)Looper對象，然后myLooper()方法通過sThreadLocal.get()方法獲取到了Looper。那么消息隊(duì)列就與線程關(guān)聯(lián)上了，所以各個(gè)線程只能訪問自己的消息隊(duì)列。

綜上所述，我們可以發(fā)現(xiàn)消息隊(duì)列通過Looper與線程關(guān)聯(lián)上了，而Looper又與Handler是關(guān)聯(lián)的，所以Handler就跟線程、線程的消息隊(duì)列關(guān)聯(lián)上了。

3.2 如何執(zhí)行消息循環(huán)？

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

    //執(zhí)行消息循環(huán)
    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;//獲取消息隊(duì)列
    //代碼省略
    for (;;) {//死循環(huán)
        Message msg = queue.next(); // 獲取消息
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
        //代碼省略
        try {
            msg.target.dispatchMessage(msg);//分發(fā)消息
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
        //代碼省略
        msg.recycleUnchecked();//消息回收
         }
    }   

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

3.3 消息處理機(jī)制

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

我們從loop中的 dispatchMessage()方法入手，看看誰是該方法的調(diào)用者，深入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;

        //代碼省略
    }

從源碼中我們可以看到其實(shí)target就是Handler類型。所以Handler是將消息發(fā)送到消息隊(duì)列暫時(shí)存儲(chǔ)下，然后又將消息發(fā)送給Handler自身去處理。那我們繼續(xù)到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.
 * 消息處理方法為一個(gè)空方法，由子類去實(shí)現(xiàn)
 */
public void handleMessage(Message msg) {
}

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

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

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

關(guān)于Handler機(jī)制補(bǔ)充如下幾點(diǎn)：

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