摘要：通過向消息池發(fā)送各種消息事件通過處理相應(yīng)的消息事件。子線程往消息隊列發(fā)送消息，并且往管道文件寫數(shù)據(jù)，主線程即被喚醒，從管道文件讀取數(shù)據(jù)，主線程被喚醒只是為了讀取消息，當(dāng)消息讀取完畢，再次睡眠。

6.0.0.1 談?wù)勏C(jī)制Hander作用？有哪些要素？流程是怎樣的？

6.0.0.2 為什么一個線程只有一個Looper、只有一個MessageQueue，可以有多個Handler？

6.0.0.3 可以在子線程直接new一個Handler嗎？會出現(xiàn)什么問題，那該怎么做？

6.0.0.4 Looper.prepare()能否調(diào)用兩次或者多次，會出現(xiàn)什么情況？

6.0.0.5 為什么系統(tǒng)不建議在子線程訪問UI，不對UI控件的訪問加上鎖機(jī)制的原因？

6.0.0.6 如何獲取當(dāng)前線程的Looper？是怎么實現(xiàn)的？（理解ThreadLocal）

6.0.0.7 Looper.loop是一個死循環(huán)，拿不到需要處理的Message就會阻塞，那在UI線程中為什么不會導(dǎo)致ANR？

6.0.0.8 Handler.sendMessageDelayed()怎么實現(xiàn)延遲的？結(jié)合Looper.loop()循環(huán)中，Message=messageQueue.next()和MessageQueue.enqueueMessage()分析。

6.0.0.9 Message可以如何創(chuàng)建？哪種效果更好，為什么？

6.0.1.3 使用Hanlder的postDealy()后消息隊列會發(fā)生什么變化？

6.0.1.4 ThreadLocal有什么作用？

博客筆記大匯總【15年10月到至今】，包括Java基礎(chǔ)及深入知識點(diǎn)，Android技術(shù)博客，Python學(xué)習(xí)筆記等等，還包括平時開發(fā)中遇到的bug匯總，當(dāng)然也在工作之余收集了大量的面試題，長期更新維護(hù)并且修正，持續(xù)完善……開源的文件是markdown格式的！同時也開源了生活博客，從12年起，積累共計500篇[近100萬字]，將會陸續(xù)發(fā)表到網(wǎng)上，轉(zhuǎn)載請注明出處，謝謝！

鏈接地址：https://github.com/yangchong2...

如果覺得好，可以star一下，謝謝！當(dāng)然也歡迎提出建議，萬事起于忽微，量變引起質(zhì)變！所有的筆記將會更新到GitHub上，同時保持更新，歡迎同行提出或者push不同的看法或者筆記！

作用：

跨線程通信。當(dāng)子線程中進(jìn)行耗時操作后需要更新UI時，通過Handler將有關(guān)UI的操作切換到主線程中執(zhí)行。

四要素：

Message（消息）：需要被傳遞的消息，其中包含了消息ID，消息處理對象以及處理的數(shù)據(jù)等，由MessageQueue統(tǒng)一列隊，最終由Handler處理。技術(shù)博客大總結(jié)

MessageQueue（消息隊列）：用來存放Handler發(fā)送過來的消息，內(nèi)部通過單鏈表的數(shù)據(jù)結(jié)構(gòu)來維護(hù)消息列表，等待Looper的抽取。

Handler（處理者）：負(fù)責(zé)Message的發(fā)送及處理。通過 Handler.sendMessage() 向消息池發(fā)送各種消息事件；通過 Handler.handleMessage() 處理相應(yīng)的消息事件。

Looper（消息泵）：通過Looper.loop()不斷地從MessageQueue中抽取Message，按分發(fā)機(jī)制將消息分發(fā)給目標(biāo)處理者。

具體流程

Handler.sendMessage()發(fā)送消息時，會通過MessageQueue.enqueueMessage()向MessageQueue中添加一條消息；

通過Looper.loop()開啟循環(huán)后，不斷輪詢調(diào)用MessageQueue.next()；

調(diào)用目標(biāo)Handler.dispatchMessage()去傳遞消息，目標(biāo)Handler收到消息后調(diào)用Handler.handlerMessage()處理消息。

注意：一個Thread只能有一個Looper，可以有多個Handler

Looper有一個MessageQueue，可以處理來自多個Handler的Message；MessageQueue有一組待處理的Message，這些Message可來自不同的Handler；Message中記錄了負(fù)責(zé)發(fā)送和處理消息的Handler；Handler中有Looper和MessageQueue。

為什么一個線程只有一個Looper？技術(shù)博客大總結(jié)

需使用Looper的prepare方法，Looper.prepare()?？梢钥聪略创a，Android中一個線程最多僅僅能有一個Looper，若在已有Looper的線程中調(diào)用Looper.prepare()會拋出RuntimeException(“Only one Looper may be created per thread”)。

所以一個線程只有一個Looper，不知道這樣解釋是否合理！更多可以查看我的博客匯總：https://github.com/yangchong2...

public static void prepare() {
    prepare(true);
}

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));
}

不同于主線程直接new一個Handler，由于子線程的Looper需要手動去創(chuàng)建，在創(chuàng)建Handler時需要多一些方法：

Handler的工作是依賴于Looper的，而Looper（與消息隊列）又是屬于某一個線程（ThreadLocal是線程內(nèi)部的數(shù)據(jù)存儲類，通過它可以在指定線程中存儲數(shù)據(jù)，其他線程則無法獲取到），其他線程不能訪問。因此Handler就是間接跟線程是綁定在一起了。因此要使用Handler必須要保證Handler所創(chuàng)建的線程中有Looper對象并且啟動循環(huán)。因為子線程中默認(rèn)是沒有Looper的，所以會報錯。

正確的使用方法是：技術(shù)博客大總結(jié)

handler = null;
new Thread(new Runnable() {
   private Looper mLooper;
   @Override
   public void run() {
       //必須調(diào)用Looper的prepare方法為當(dāng)前線程創(chuàng)建一個Looper對象，然后啟動循環(huán)
       //prepare方法中實質(zhì)是給ThreadLocal對象創(chuàng)建了一個Looper對象
       //如果當(dāng)前線程已經(jīng)創(chuàng)建過Looper對象了，那么會報錯
       Looper.prepare();
       handler = new Handler();
       //獲取Looper對象
       mLooper = Looper.myLooper();
       //啟動消息循環(huán)
       Looper.loop();
       //在適當(dāng)?shù)臅r候退出Looper的消息循環(huán)，防止內(nèi)存泄漏
       mLooper.quit();
   }
}).start();

主線程中默認(rèn)是創(chuàng)建了Looper并且啟動了消息的循環(huán)的，因此不會報錯：應(yīng)用程序的入口是ActivityThread的main方法，在這個方法里面會創(chuàng)建Looper，并且執(zhí)行Looper的loop方法來啟動消息的循環(huán)，使得應(yīng)用程序一直運(yùn)行。

Looper.prepare()方法源碼分析

可以看到Looper中有一個ThreadLocal成員變量，熟悉JDK的同學(xué)應(yīng)該知道，當(dāng)使用ThreadLocal維護(hù)變量時，ThreadLocal為每個使用該變量的線程提供獨(dú)立的變量副本，所以每一個線程都可以獨(dú)立地改變自己的副本，而不會影響其它線程所對應(yīng)的副本。

public static void prepare() {
    prepare(true);
}

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));
}

思考：Looper.prepare()能否調(diào)用兩次或者多次

如果運(yùn)行，則會報錯，并提示prepare中的Excetion信息。由此可以得出在每個線程中Looper.prepare()能且只能調(diào)用一次

技術(shù)博客大總結(jié)

//這里L(fēng)ooper.prepare()方法調(diào)用了兩次
Looper.prepare();
Looper.prepare();
Handler mHandler = new Handler() {
   @Override
   public void handleMessage(Message msg) {
       if (msg.what == 1) {
          Log.i(TAG, "在子線程中定義Handler，并接收到消息。。。");
       }
   }
};
Looper.loop();

為什么系統(tǒng)不建議在子線程訪問UI

系統(tǒng)不建議在子線程訪問UI的原因是，UI控件非線程安全，在多線程中并發(fā)訪問可能會導(dǎo)致UI控件處于不可預(yù)期的狀態(tài)。

不對UI控件的訪問加上鎖機(jī)制的原因

上鎖會讓UI控件變得復(fù)雜和低效

上鎖后會阻塞某些進(jìn)程的執(zhí)行技術(shù)博客大總結(jié)

問題描述

在處理消息的時候使用了Looper.loop()方法，并且在該方法中進(jìn)入了一個死循環(huán)，同時Looper.loop()方法是在主線程中調(diào)用的，那么為什么沒有造成阻塞呢？

ActivityThread中main方法

ActivityThread類的注釋上可以知道這個類管理著我們平常所說的主線程(UI線程)

首先 ActivityThread 并不是一個 Thread，就只是一個 final 類而已。我們常說的主線程就是從這個類的 main 方法開始，main 方法很簡短

public static final void main(String[] args) {
    ...
    //創(chuàng)建Looper和MessageQueue
    Looper.prepareMainLooper();
    ...
    //輪詢器開始輪詢
    Looper.loop();
    ...
}

Looper.loop()方法無限循環(huán)

看看Looper.loop()方法無限循環(huán)部分的代碼

while (true) {
   //取出消息隊列的消息，可能會阻塞
   Message msg = queue.next(); // might block
   ...
   //解析消息，分發(fā)消息
   msg.target.dispatchMessage(msg);
   ...
}

為什么這個死循環(huán)不會造成ANR異常呢？

因為Android 的是由事件驅(qū)動的，looper.loop() 不斷地接收事件、處理事件，每一個點(diǎn)擊觸摸或者說Activity的生命周期都是運(yùn)行在 Looper.loop() 的控制之下，如果它停止了，應(yīng)用也就停止了。只能是某一個消息或者說對消息的處理阻塞了 Looper.loop()，而不是 Looper.loop() 阻塞它。技術(shù)博客大總結(jié)

處理消息handleMessage方法

如下所示

可以看見Activity的生命周期都是依靠主線程的Looper.loop，當(dāng)收到不同Message時則采用相應(yīng)措施。

如果某個消息處理時間過長，比如你在onCreate(),onResume()里面處理耗時操作，那么下一次的消息比如用戶的點(diǎn)擊事件不能處理了，整個循環(huán)就會產(chǎn)生卡頓，時間一長就成了ANR。

public void handleMessage(Message msg) {
    if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
    switch (msg.what) {
        case LAUNCH_ACTIVITY: {
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
            final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
            r.packageInfo = getPackageInfoNoCheck(r.activityInfo.applicationInfo, r.compatInfo);
            handleLaunchActivity(r, null);
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        }
        break;
        case RELAUNCH_ACTIVITY: {
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityRestart");
            ActivityClientRecord r = (ActivityClientRecord) msg.obj;
            handleRelaunchActivity(r);
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        }
        break;
        case PAUSE_ACTIVITY:
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
            handlePauseActivity((IBinder) msg.obj, false, (msg.arg1 & 1) != 0, msg.arg2, (msg.arg1 & 2) != 0);
            maybeSnapshot();
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            break;
        case PAUSE_ACTIVITY_FINISHING:
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
            handlePauseActivity((IBinder) msg.obj, true, (msg.arg1 & 1) != 0, msg.arg2, (msg.arg1 & 1) != 0);
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            break;
        ...........
    }
}

loop的循環(huán)消耗性能嗎？

主線程Looper從消息隊列讀取消息，當(dāng)讀完所有消息時，主線程阻塞。子線程往消息隊列發(fā)送消息，并且往管道文件寫數(shù)據(jù)，主線程即被喚醒，從管道文件讀取數(shù)據(jù)，主線程被喚醒只是為了讀取消息，當(dāng)消息讀取完畢，再次睡眠。因此loop的循環(huán)并不會對CPU性能有過多的消耗。

簡單的來說：ActivityThread的main方法主要就是做消息循環(huán)，一旦退出消息循環(huán)，那么你的程序也就可以退出了。

創(chuàng)建Message對象的幾種方式：技術(shù)博客大總結(jié)

Message msg = new Message();

Message msg = Message.obtain();

Message msg = handler1.obtainMessage();

后兩種方法都是從整個Messge池中返回一個新的Message實例，能有效避免重復(fù)Message創(chuàng)建對象，因此更鼓勵這種方式創(chuàng)建Message

runOnUiThread如何實現(xiàn)子線程更新UI

看看源碼，如下所示

如果msg.callback為空的話，會直接調(diào)用我們的mCallback.handleMessage(msg)，即handler的handlerMessage方法。由于Handler對象是在主線程中創(chuàng)建的，所以handler的handlerMessage方法的執(zhí)行也會在主線程中。

在runOnUiThread程序首先會判斷當(dāng)前線程是否是UI線程，如果是就直接運(yùn)行，如果不是則post，這時其實質(zhì)還是使用的Handler機(jī)制來處理線程與UI通訊。

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

@Override
public final void runOnUiThread(Runnable action) {
    if (Thread.currentThread() != mUiThread) {
        mHandler.post(action);
    } else {
        action.run();
    }
}

post delay的Message并不是先等待一定時間再放入到MessageQueue中，而是直接進(jìn)入并阻塞當(dāng)前線程，然后將其delay的時間和隊頭的進(jìn)行比較，按照觸發(fā)時間進(jìn)行排序，如果觸發(fā)時間更近則放入隊頭，保證隊頭的時間最小、隊尾的時間最大。此時，如果隊頭的Message正是被delay的，則將當(dāng)前線程堵塞一段時間，直到等待足夠時間再喚醒執(zhí)行該Message，否則喚醒后直接執(zhí)行。

線程本地存儲的功能

ThreadLocal類可實現(xiàn)線程本地存儲的功能，把共享數(shù)據(jù)的可見范圍限制在同一個線程之內(nèi)，無須同步就能保證線程之間不出現(xiàn)數(shù)據(jù)爭用的問題，這里可理解為ThreadLocal幫助Handler找到本線程的Looper。

技術(shù)博客大總結(jié)

怎么存儲呢？底層數(shù)據(jù)結(jié)構(gòu)是啥？

每個線程的Thread對象中都有一個ThreadLocalMap對象，它存儲了一組以ThreadLocal.threadLocalHashCode為key、以本地線程變量為value的鍵值對，而ThreadLocal對象就是當(dāng)前線程的ThreadLocalMap的訪問入口，也就包含了一個獨(dú)一無二的threadLocalHashCode值，通過這個值就可以在線程鍵值值對中找回對應(yīng)的本地線程變量。

1.技術(shù)博客匯總

2.開源項目匯總

3.生活博客匯總

4.喜馬拉雅音頻匯總

5.其他匯總

我的個人站點(diǎn)：www.yczbj.org， www.ycbjie.cn

github：https://github.com/yangchong211

知乎：https://www.zhihu.com/people/...

簡書：http://www.jianshu.com/u/b7b2...

csdn：http://my.csdn.net/m0_37700275

喜馬拉雅聽書：http://www.ximalaya.com/zhubo...

開源中國：https://my.oschina.net/zbj161...

泡在網(wǎng)上的日子：http://www.jcodecraeer.com/me...

郵箱：[email protected]

阿里云博客：https://yq.aliyun.com/users/a... 239.headeruserinfo.3.dT4bcV

segmentfault頭條：https://segmentfault.com/u/xi...

掘金：https://juejin.im/user/593943...