1. 前言
在Android開發(fā)中，Handler機制是一個很重要的知識點，主要作用是消息通信。
下面是Handler機制的原理圖，先不要急，等看完這篇文章，這個圖就很簡單了。
2. Handler的簡單使用
我們一般使用handler發(fā)送消息，只需要兩步，首先是創(chuàng)建一個Handler對象，并重寫handleMessage方法，就是上圖中的3（Message.target.handleMeesage），然后需要消息通信的地方，通過Handler的sendMessage方法發(fā)送消息（這里我們創(chuàng)建了一個子線程，模擬子線程向主線程發(fā)送消息）。代碼如下：
public class MainActivity extends Activity {
private static final String TAG = "MainActivity";
private Handler mHandler;
private Button btnSendeToMainThread;
private static final int MSG_SUB_TO_MAIN= 100;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 1.創(chuàng)建Handler，并重寫handleMessage方法
mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
// 處理消息
switch (msg.what) {
case MSG_SUB_TO_MAIN:
// 打印出處理消息的線程名和Message.obj
Log.e(TAG, "接收到消息： " + Thread.currentThread().getName() + ","+ msg.obj);
break;
default:
break;
}
}
};
btnSendeToMainThread = (Button) findViewById(R.id.btn_sendto_mainthread);
btnSendeToMainThread .setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// 創(chuàng)建一個子線程，在子線程中發(fā)送消息
new Thread(new Runnable() {
@Override
public void run() {
Message msg = Message.obtain();
msg.what = MSG_SUB_TO_MAIN;
msg.obj = "這是一個來自子線程的消息";
// 2.發(fā)送消息
mHandler.sendMessage(msg);
}
}).start();
}
});
}
}
點擊了發(fā)送按鈕，看log：
這樣就完成子線程向主線程發(fā)送消息，辣么，如果想要主線程向子線程發(fā)送消息呢？是否也只要在子線程中創(chuàng)建Handler對象，然后在主線程中拿到子線程的Handler以后，調用sendMessage發(fā)送消息。在onCreate中添加如下代碼：
// 創(chuàng)建一個子線程，并在子線程中創(chuàng)建一個Handler，且重寫handleMessage
new Thread(new Runnable() {
@Override
public void run() {
subHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
// 處理消息
switch (msg.what) {
case MSG_MAIN_TO_SUB:
Log.e(TAG, "接收到消息： " + Thread.currentThread().getName() + ","+ msg.obj);
break;
default:
break;
}
}
};
}
}).start();
btnSendToSubThread = (Button) findViewById(R.id.btn_sendto_subthread);
btnSendToSubThread.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Message msg = Message.obtain();
msg.what = MSG_MAIN_TO_SUB;
msg.obj = "這是一個來自主線程的消息";
// 主線程中發(fā)送消息
subHandler.sendMessage(msg);
}
});
我們點擊按鈕時，發(fā)現(xiàn)并沒有成功，并且報出了如下的錯誤信息：
原因也說得很清楚了，說的是我們不能在一個沒有調用Looper.prepare()的線程去創(chuàng)建Handler對象。那為什么主線程我們不需要去手動調用Looper.prepare()就可以直接使用Handler呢？原來是啟動App時，系統(tǒng)幫我們創(chuàng)建好了，App的入口，是ActivityThread.main方法，代碼如下：
public static void main(String[] args) {
// 不相干代碼
......
// 1.調用Looper.prepareMainLooper，其實也就是調用的Looper.loop，初始化Looper、MessageQueue等
Looper.prepareMainLooper();
// 2.創(chuàng)建ActivityThread的同時，初始化了成員變量Handler mH
ActivityThread thread = new ActivityThread();
thread.attach(false);
//
if (sMainThreadHandler == null) {
// 把創(chuàng)建的Handler mH賦值給sMainThreadHandler
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// 3.調用Looper.loop()方法，開啟死循環(huán)，從MessageQueue中不斷取出Message來處理
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
看樣子，創(chuàng)建Handler還是需要調用Looper.prepare的，我們平常在主線程不需要手動調用，是因為系統(tǒng)在啟動App時，就幫我們調用了。并且還需要調用Looper.loop方法，這個方法后面我們會講到。所以使用Handler通信之前需要有以下三步：
- 調用Looper.prepare()
- 創(chuàng)建Handler對象
- 調用Looper.loop()
那按照這個套路，我們完善下之前的代碼，其實就是在子線程中創(chuàng)建Handler之前調用Looper.prepare()，之后調用Looper.loop()方法，如下：
// 創(chuàng)建一個子線程，并在子線程中創(chuàng)建一個Handler，且重寫handleMessage
new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
subHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
// 處理消息
switch (msg.what) {
case MSG_MAIN_TO_SUB:
Log.e(TAG, "接收到消息： " + Thread.currentThread().getName() + ","+ msg.obj);
break;
default:
break;
}
}
};
Looper.loop();
}
}).start();
這時候再點擊按鈕，在主線程向子線程發(fā)送消息，log如下圖。
現(xiàn)在就可以使用Handler在主線程向子線程發(fā)送消息了,且可以看到，是在子線程中處理消息的。
3. Handler機制原理
Handler機制，主要牽涉到的類有如下四個，它們分工明確，但又相互作用
- Message：消息
- Hanlder：消息的發(fā)起者
- Looper：消息的遍歷者
- MessageQueue：消息隊列
下面我們從Handler的套路，來一一分析他們的作用
3.1 Looper.prepare()
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
// 規(guī)定了一個線程只有一個Looper，也就是一個線程只能調用一次Looper.prepare()
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
// 如果當前線程沒有Looper，那么就創(chuàng)建一個，存到sThreadLocal中
sThreadLocal.set(new Looper(quitAllowed));
}
從上面的代碼可以看出，一個線程最多只有一個Looper對象。當沒有Looper對象時，去創(chuàng)建一個Looper，并存放到sThreadLocal中，sThreadLocal是一個static的ThreadLocal對象，關于它的詳細使用，以后有機會再介紹，這里只要知道，它存儲了Looper對象的副本，并且可以通過它取得當前線程在之前存儲的Looper的副本。如下圖：
接下來看Looper的構造方法：
private Looper(boolean quitAllowed) {
// 創(chuàng)建了MessageQueue，并供Looper持有
mQueue = new MessageQueue(quitAllowed);
// 讓Looper持有當前線程對象
mThread = Thread.currentThread();
}
這里主要就是創(chuàng)建了消息隊列MessageQueue，并讓它供Looper持有，因為一個線程最大只有一個Looper對象，所以一個線程最多也只有一個消息隊列。然后再把當前線程賦值給mThread。
MessageQueue的構造方法沒有什么可講的，它就是一個消息隊列，用于存放Message。
所以Looper.prepare()的作用主要有以下三點
- 創(chuàng)建Looper對象
- 創(chuàng)建MessageQueue對象，并讓Looper對象持有
- 讓Looper對象持有當前線程
3.2 new Handler()
Handler有很多構造方法，主要是提供自定義Callback、Looper等，我們先從最簡單的無參構造方法看起：
public Handler() {
this(null, false);
}
public Handler(Callback callback, boolean async) {
// 不相關代碼
......
//得到當前線程的Looper，其實就是調用的sThreadLocal.get
mLooper = Looper.myLooper();
// 如果當前線程沒有Looper就報運行時異常
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
// 把得到的Looper的MessagQueue讓Handler持有
mQueue = mLooper.mQueue;
// 初始化Handler的Callback，其實就是最開始圖中的回調方法的2
mCallback = callback;
mAsynchronous = async;
}
首先，調用了Looper.myLooper，其實就是調用sThreadLocal.get方法，會得到當前線程調用sThreadLocal.set保存的Looper對象，讓Handler持有它。接下來就會判斷得到的Looper對象是否為空，如果為空，就會報
"Can't create handler inside thread that has not called Looper.prepare()，這不就是我們之前在沒有調用Looper.prepare就在子線程中創(chuàng)建Handler時報的錯誤嘛。的確，當我們沒有調用Looper.prepare()，則當前線程中是沒有Looper對象的。
然后，讓Handler持有得到的Looper對象的MessageQueue和設置處理回調的Callback對象（最開始圖中的回調方法2）。
到這里，默認的Handler的創(chuàng)建過程就結束了，主要有以下幾點
- 創(chuàng)建Handler對象
- 得到當前線程的Looper對象，并判斷是否為空
- 讓創(chuàng)建的Handler對象持有Looper、MessageQueu、Callback的引用
2.3 Looper.loop()
public static void loop() {
// 得到當前線程的Looper對象
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
// 得到當前線程的MessageQueue對象
final MessageQueue queue = me.mQueue;
// 無關代碼
......
// 死循環(huán)
for (;;) {
// 不斷從當前線程的MessageQueue中取出Message，當MessageQueue沒有元素時，方法阻塞
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
// Message.target是Handler，其實就是發(fā)送消息的Handler，這里就是調用它的dispatchMessage方法
msg.target.dispatchMessage(msg);
// 回收Message
msg.recycleUnchecked();
}
}
首先還是判斷了當前線程是否有Looper，然后得到當前線程的MessageQueue。接下來，就是最關鍵的代碼了，寫了一個死循環(huán)，不斷調用MessageQueue的next方法取出MessageQueue中的Message，注意，當MessageQueue中沒有消息時，next方法會阻塞，導致當前線程掛起，后面會講到。
拿到Message以后，會調用它的target的dispatchMessage方法，這個target其實就是發(fā)送消息時用到的Handler。所以就是調用Handler的dispatchMessage方法，代碼如下：
public void dispatchMessage(Message msg) {
// 如果msg.callback不是null，則調用handleCallback
if (msg.callback != null) {
handleCallback(msg);
} else {
// 如果 mCallback不為空，則調用mCallback.handleMessage方法
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
// 調用Handler自身的handleMessage，這就是我們常常重寫的那個方法
handleMessage(msg);
}
}
可以看出，這個方法就是從MessageQueue中取出Message以后，進行分發(fā)處理。
首先，判斷msg.callback是不是空，其實msg.callback是一個Runnable對象，是Handler.post方式傳遞進來的參數(shù)，后面會講到。而hanldeCallback就是調用的Runnable的run方法。
然后，判斷mCallback是否為空，這是一個Handler.Callback的接口類型，之前說了Handler有多個構造方法，可以提供設置Callback，如果這里不為空，則調用它的hanldeMessage方法，注意，這個方法有返回值，如果返回了true，表示已經(jīng)處理 ，不再調用Handler的handleMessage方法；如果mCallback為空，或者不為空但是它的handleMessage返回了false，則會繼續(xù)調用Handler的handleMessage方法，該方法就是我們經(jīng)常重寫的那個方法。
關于從MessageQueue中取出消息以后的分發(fā)，如下面的流程圖所示：
所以Looper.loop的作用就是：從當前線程的MessageQueue從不斷取出Message，并調用其相關的回調方法。
2.4 發(fā)送消息
使用Handler發(fā)送消息主要有兩種，一種是sendXXXMessage方式，還有一個postXXX方式，不過兩種方式最后都會調用到sendMessageDelayed方法，所以我們就以最簡單的sendMessage方法來分析。
我們先來看Handler的sendMessage方法：
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
// 這里拿到的MessageQueue其實就是創(chuàng)建時的MessageQueue，默認情況是當前線程的Looper對象的MessageQueue
// 也可以指定
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
// 調用enqueueMessage，把消息加入到MessageQueue中
return enqueueMessage(queue, msg, uptimeMillis);
}
主要實現(xiàn)是調用enqueueMessage來實現(xiàn)的，看看該方法：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
// 把當前Handler對象，也就是發(fā)起消息的handler作為Message的target屬性
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
// 調用MessageQueue中的enqueueMessage方法
return queue.enqueueMessage(msg, uptimeMillis);
}
首先，把當前Handler作為Message的target屬性，方便Looper從MessageQueue中取出Message時進行消息處理。然后調用了MessageQueue的enqueueMessage方法，把handler發(fā)送的消息加入到MessageQueue，供Looper去取出來處理。我們記下來看看MessageQueue的enqueueMessage方法：
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
// 一個Message，只能發(fā)送一次
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
if (mQuitting) {
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w("MessageQueue", e.getMessage(), e);
msg.recycle();
return false;
}
// 標記Message已經(jīng)使用了
msg.markInUse();
msg.when = when;
// 得到當前消息隊列的頭部
Message p = mMessages;
boolean needWake;
// 我們這里when為0，表示立即處理的消息
if (p == null || when == 0 || when < p.when) {
// 把消息插入到消息隊列的頭部
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
// 根據(jù)需要把消息插入到消息隊列的合適位置，通常是調用xxxDelay方法，延時發(fā)送消息
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
// 把消息插入到合適位置
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}
// 如果隊列阻塞了，則喚醒
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
首先，判斷了Message是否已經(jīng)使用過了，如果使用過，則直接拋出異常，這是可以理解的，如果MessageQueue中已經(jīng)存在一個Message，但是還沒有得到處理，這時候如果再發(fā)送一次該Message，可能會導致處理前一個Message時，出現(xiàn)問題。
然后，會判斷when，它是表示延遲的時間，我們這里沒有延時，所以為0，滿足if條件。把消息插入到消息隊列的頭部。如果when不為0，則需要把消息加入到消息隊列的合適位置。
最后會去判斷當前線程是否已經(jīng)阻塞了，如果阻塞了，則需要調用本地方法去喚醒它。
以上是sendMessage的全部過程，其實就是把Message加入到MessageQueue的合適位置。那我們來簡單看看post系列方法：
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
// 構造一個Message，并讓其callback執(zhí)行傳來的Runnable
Message m = Message.obtain();
m.callback = r;
return m;
}
可以看到，post方法只是先調用了getPostMessage方法，用Runnable去封裝一個Message，然后就調用了sendMessageDelayed，把封裝的Message加入到MessageQueue中。
所以使用handler發(fā)送消息的本質都是：把Message加入到Handler中的MessageQueue中去。
4. 總結
我們再來總結下Handler消息機制主要的四個類的功能
- Message:信息的攜帶者，持有了Handler，存在MessageQueue中，一個線程可以有多個
- Hanlder:消息的發(fā)起者，發(fā)送Message以及消息處理的回調實現(xiàn)，一個線程可以有多個Handler對象
- Looper:消息的遍歷者，從MessageQueue中循環(huán)取出Message進行處理，一個線程最多只有一個
- MessageQueue:消息隊列，存放了Handler發(fā)送的消息，供Looper循環(huán)取消息，一個線程最多只有一個
再來看看開始的結構圖，是不是一目了然了：
6. 課后題
- Android中，有哪些是基于Handler來實現(xiàn)通信的？
- 處理Handler消息，是在哪個線程？一定是創(chuàng)建Handler的線程么？
- 消息是如何插入到MessageQueue中的？
- 當MessageQueue沒有消息時，它的next方法是阻塞的，會導致App ANR么？
- 子線程中可以使用Toast么？
- Looper.loop()是死循環(huán)，可以停止么？
- Handler內存泄露怎么解決？
篇幅問題，放到下一篇詳解，點擊Handler課后題
