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

在敦化等地區(qū)，都構(gòu)建了全面的區(qū)域性戰(zhàn)略布局，加強發(fā)展的系統(tǒng)性、市場前瞻性、產(chǎn)品創(chuàng)新能力，以專注、極致的服務理念，為客戶提供網(wǎng)站設計制作、成都網(wǎng)站設計 網(wǎng)站設計制作按需求定制設計,公司網(wǎng)站建設,企業(yè)網(wǎng)站建設,成都品牌網(wǎng)站建設,成都全網(wǎng)營銷推廣,外貿(mào)網(wǎng)站制作,敦化網(wǎng)站建設費用合理。

1. Handler的一般使用步驟

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

1. 在主線程中創(chuàng)建Handler實例，并且重寫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的一種使用方式，由于本文的重點是探究Handlerde原理，故其他使用方式這里不重點介紹。

2. 重要類的職責

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

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

3. Handler機制原理

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

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

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

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

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

我們首先看Handler默認的構(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對象獲取消息隊列
        mCallback = callback;
        mAsynchronous = async;
    }

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

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

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

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

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

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

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

在創(chuàng)建Looper對象后，通過Handler發(fā)來的消息放在消息隊列中后是如何被處理的呢？這就涉及到了消息循環(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;//獲取消息隊列
    //代碼省略
    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()方法實質(zhì)上就是通過一個死循環(huán)不斷的從消息隊列中獲取消息，然后又不斷的處理消息的過程。

3.3 消息處理機制

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;

        //代碼省略
    }

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

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

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

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

關(guān)于Handler機制補充如下幾點：

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

網(wǎng)頁標題：解析Android中Handler機制原理
本文地址：http://www.rwnh.cn/article14/jeesge.html

成都網(wǎng)站建設公司_創(chuàng)新互聯(lián)，為您提供搜索引擎優(yōu)化、微信公眾號、自適應網(wǎng)站、網(wǎng)站制作、企業(yè)建站、App開發(fā)

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)