Handler通常都會面被問到這幾個問題

1.一個執行緒有幾個Handler?
2.一個執行緒有幾個Looper?如何保證?
3.Handler記憶體泄漏原因?
4.子執行緒中可以new Handler嗎?
5.子執行緒中維護的Looper,訊息佇列無訊息的時候的處理方案是什么?有什么用?主執行緒呢?
6.既然可以存在多個Handler往MessageQueue中添加資料(發訊息時各個Handler可能處于不同執行緒)，那它內部是如何確保執行緒安全的?取訊息呢?
7.我們使用Message時應該如何創建它

Handler的流程

這是我在網上看到的一張圖，很形象的體現Handler的作業流程，也說明了Handler幾個關鍵類之間的關系

Handler 只負責將message放到MessageQueue，然后再從MessageQueue取出message發送出去

MessageQueue 就是傳送帶，上面一直傳送的許多message

Looper 就是傳送帶的輪子，他帶動這MessageQueue一直跑動

Thread 就是動力，要是沒有執行緒，整個傳送都不會開始，并且Looper還提供了一個開關給Thread，開啟才會傳送

MessageQueue 和 Message

添加訊息

只要你使用handler發送訊息，最后都會走到handler#enqueueMessag
然后呼叫MessageQueue#enqueueMessage，可以看到方法需要傳入一個Message的

handler#enqueueMessage

MessageQueue#enqueueMessage

而且MessageQueue里面還存放了一個mMessage變數，有什么作用呢，讓我們先來看一下Message 是什么

Message就是我們所發送的一個個訊息體，而在這個類中
可以看到，一個Message變數里，又存放一個Message叫做next，存放下一個Message的，這又有啥用呢

再次回到MessageQueue#enqueueMessage，看一看這些變數到底有什么作用

首先第一個msg1進入時，p = mMessage = null，所以進入第一個if陳述句
所以msg1.next = p = null，mMessage = msg1

而第二個msg2進入時，假設msg2的執行時間when是在msg1之后的，
此時p = mMessage = msg1，而when(msg2.when) > p.when(msg1.when)
則if陳述句就不成立了,會進入else陳述句的for回圈

此時的prev = p = mMessage = msg1，
而p = p.next(p就是msg1，msg1.next = null)，此時的p就為null
所以break出去后，for回圈也結束了

最后兩句就是做了下圖的操作
msg2.next = p = null
prev.next（msg1.next） = msg2

結構就像這樣，通過這樣的賦值操作，這樣就形成了一個鏈表結構
所以MessageQueue就相當于是一個倉庫，里面存放著由許許多多的Message組成的鏈條

取訊息

取訊息的方法是MessageQueue#next()方法，里面的代碼先不做分析，
我們知道發送訊息是handler呼叫的
那么取訊息是誰呼叫的呢

根據一開始的圖很容易知道，是Loop#loop()呼叫了該方法
而在這個方法拿到msg后會呼叫 msg.target.dispatchMessage(msg)將訊息發送出去，這里的msg.target 就是 handler

所以他們形成了這樣一種模式，一種生產者消費者模型

也就是說要呼叫Looper.loop()才會取出訊息去分發，但是我們再主執行緒的時候，都是直接使用Handler，是哪里幫我們呼叫了Looper.loop()函式呢，直接看到主執行緒的main函式就能看到，也就是說app一啟動，主執行緒就幫我們呼叫了Looper.loop()函式

知道流程后，回到一開始的問題

1.一個執行緒有幾個Handler?

這個問題其實不用說都知道，難道主執行緒不能使用多個Handler嗎

2.一個執行緒有幾個Looper?如何保證?

答案很簡單，一個執行緒只有一個Looper，但是怎么保證的呢？

我們先來看看Looper是怎么創建的，是誰創建的
可以看到，Looper的建構式只在prepare這里使用過，而且系統也有提示我們，

但是Looper存放在了sThreadLocal變數中，所以先看看sThreadLocal是什么
查閱到就是Looper中的一個靜態變數的ThreadLocal類，好像看不出什么

那就進入sThreadLocal.set(Looper)方法看一下

1.可以看到set方法中，首先獲取了當前執行緒，則prepare() --> set() --> 當前執行緒
也就是說，Thread1呼叫prepare方法，獲取的當前執行緒也就是Thread1，不可能為其他執行緒，
2.然后通過getMap(當前執行緒)獲得ThreadLocalMap,也就是說Thead和ThreadLocalMap有關系，也可以看到Thread中有ThreadLocalMap的變數

3.最后將this(當前ThreadLocal)與傳入的Looper保存在ThreadLocalMap中
4.ThreadLocalMap就是一個保存<key,value>鍵值對的

所以看一下 Thread，ThreadLocalMap，ThreadLocal，Looper的關系

所以這里保證了一個Thread對應一個ThreadLocalMap，而ThreadLocalMap又保存這該Thread的ThreadLocal，問題來了<key,vaule>中key是唯一的，但是value是可以代替的，怎么能做到<ThreadLocal,Looper>保存之后Looper不會被代替呢

再回到prepare函式，可以看到在new Looper之前，還有一個get()操作

get函式做了一個操作，就是查看當前Thread對應的ThreadLocal，在ThreadLocalMap有沒有值，有值則在prepare拋出例外
也就是說，prepare在一個執行緒中，只能夠呼叫一次，也就保證了Looper只能生成一次，也就是唯一的

3.Handler記憶體泄漏原因?

我們知道，handler不能作為內部類存在，不然有可能會導致記憶體泄漏，為什么其他內部類不會呢？

通過java語法我們知道：匿名內部類持有外部類的物件
比如這個，handler是持有HandlerActivity的，不然也不能夠呼叫到其中的方法，而系統是直接幫我們省略了HandlerActivity.this部分的

這就表示**Handler ---持有--> this.Activity --持有--> Activity的一切內容 = 大量記憶體**

首先我們知道，一個message是通過handler發送的，然后MessageQueue會保存

也就是說 MessageQueue ---持有--> message

接著我們再看看handler#enqueueMessage，我認為紅框就是造成記憶體泄漏的最主要原因，我們通過代碼可以看到 message.traget = this

這就意味著 message ---持有--> Handler物件

將三條鏈路拼接在一起 MessageQueue ---持有--> message ---持有--> Handler物件 ---持有--> this.Activity --持有--> Activity的一切內容 = 大量記憶體

當Handler發送了一個延遲10s的message，但是5s的時候，Activity銷毀了，
此時的message是沒有人處理的，即使他已經從MessageQueue扔出去了，但是Activity銷毀了沒人接收，也就是說這個message一只存在，則上面的這條鏈路是一只存在的，所以這持有的大量記憶體一直沒人處理，虛擬機也會認為你這塊記憶體是被持有的，他不會回收，就這樣造成了記憶體泄漏，

所以說，Handler的記憶體泄漏，是說是因為匿名內部類是不夠全面的

4.子執行緒中可以new Handler嗎?

答案是可以的，
主執行緒和子執行緒都是執行緒，憑啥子執行緒不行呢，而且看了這么多代碼也沒看到什么地方必須要做主執行緒執行的方法，

下面用一段代碼演示一下怎么在子執行緒創建Handler
首先要自定義自己的執行緒，在執行緒中創建出自己的Looper

然后再將子執行緒的Looper傳給Handler，這樣創建的Handler就是子執行緒的了

但是這樣寫會有問題嗎，顯然是有的

我們知道子執行緒是異步的，而在子執行緒生成和獲取Looper，你怎么知道他什么時候能創建好，怎么知道在Handler創建時，Looper是有值的呢？這一下變成了執行緒同步問題了，很簡單，執行緒同步就加鎖唄，實際上，系統已經寫好了一個能在子執行緒創建Handler的 HandlerThread

可以看到總體還是和我們自己寫的差不多的，不過在自己獲取Looper和暴露給外界獲取Looper加上了鎖

也就是說，如果我們在looper還沒創建出來時呼叫getLooper會執行wait()，釋放鎖且等待

直到run方法拿到鎖之后，獲取到Looper后去notiftAll()喚醒他
這樣就能保證在Handler創建時，Looper是一定有的

5.子執行緒中維護的Looper,訊息佇列無訊息的時候的處理方案是什么?有什么用?主執行緒呢?

我們知道Looper會幫我們在MessageQueue里面取訊息，當MessageQueue沒有訊息了，Looper會做什么呢

首先看到獲取訊息的next()方法，他會呼叫到native層的方法nativePollOnce，當nativePollOnce取不到訊息時，他就會讓執行緒等待

所以此時的Looper.loop()方法中，系統也提示我們，會在這里阻塞住
而Looper.loop()是在子執行緒的run中運行的，要是一直沒訊息，他就會一直阻塞，run方法一直沒辦法結束，執行緒也沒辦法釋放，就會造成記憶體泄露了

所以Looper給我們提供了一個方法quitSafely，而他會呼叫到MessageQueue的方法

他會讓mQuitting = true;,接著清除message，接著nativeWake, 這與nativePollOnce是一對的，他會喚醒nativePollOnce繼續執行

所以quitSafely后，next()方法會繼續，因為msg = null，mQuitting = true，導致next()直接回傳 null

然后再看呼叫next()方法的Looper.loop()，msg為null后直接return，for回圈退出，loop方法也結束了，這樣執行緒也能得到釋放了

6.既然可以存在多個Handler往MessageQueue中添加資料(發訊息時各個Handler可能處于不同執行緒)，那它內部是如何確保執行緒安全的?取訊息呢?

我們知道Looper創建時，會創建一個MessageQueue，且是唯一對應的
這也就說明一個Thread，Looper，MessageQueue都是唯一對應的關系

那么在添加訊息時，synchronized (this) 的this 就是MessageQueue，而根據對應關系，這里加鎖，其實就等于鎖住了當前執行緒，就一個執行緒內算多個Handler同時添加訊息，他們也會被鎖限制，從而保證了訊息添加的有序性，取訊息同理

7.我們使用Message時應該如何創建它

不知道你們有沒有人使用new Message()去創建訊息，雖然是可以的，但是如果瘋狂的new Message，你每new一個，就占用一塊記憶體，會占用大量的記憶體和記憶體碎片

系統也提供了新建Message的方法，發現還是new Message()，那又有什么不同呢，
不同的就是sPool，他也是一個Message變數

我們回到Looper，沒處理完一個訊息后，他會呼叫Message的方法

而這個方法就是將當前的Message的所有引數清空，變成一個空的Message物件，然后放到sPool中去，等你一下需要Message變數時，他就可以重復里面