图解Handler机制
1. 前言
在Android开发中，Handler机制是一个很重要的知识点，主要作用是消息通信。
下面是Handler机制的原理图，先不要急，等看完这篇文章，这个图就很简单了。
Handler机制.png
2. Handler的简单使用
我们一般使用handler发送消息，只需要两步，首先是创建一个Handler对象，并重写handleMessage方法，就是上图中的3（Message.target.handleMeesage），然后需要消息通信的地方，通过Handler的sendMessage方法发送消息（这里我们创建了一个子线程，模拟子线程向主线程发送消息）。代码如下：
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.创建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) {
// 创建一个子线程，在子线程中发送消息
new Thread(new Runnable() {
@Override
public void run() {
Message msg = Message.obtain();
msg.what = MSG_SUB_TO_MAIN;
msg.obj = "这是一个来自子线程的消息";
// 2.发送消息
mHandler.sendMessage(msg);
}
}).start();
}
});
}
}
点击了发送按钮，看log：
image.png
这样就完成子线程向主线程发送消息，辣么，如果想要主线程向子线程发送消息呢？是否也只要在子线程中创建Handler对象，然后在主线程中拿到子线程的Handler以后，调用sendMessage发送消息。在onCreate中添加如下代码：
// 创建一个子线程，并在子线程中创建一个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 = "这是一个来自主线程的消息";
// 主线程中发送消息
subHandler.sendMessage(msg);
}
});
我们点击按钮时，发现并没有成功，并且报出了如下的错误信息：
image.png
原因也说得很清楚了，说的是我们不能在一个没有调用Looper.prepare()的线程去创建Handler对象。那为什么主线程我们不需要去手动调用Looper.prepare()就可以直接使用Handler呢？原来是启动App时，系统帮我们创建好了，App的入口，是ActivityThread.main方法，代码如下：
public static void main(String[] args) {
// 不相干代码
......
// 1.调用Looper.prepareMainLooper，其实也就是调用的Looper.loop，初始化Looper、MessageQueue等
Looper.prepareMainLooper();
// 2.创建ActivityThread的同时，初始化了成员变量Handler mH
ActivityThread thread = new ActivityThread();
thread.attach(false);
//
if (sMainThreadHandler == null) {
// 把创建的Handler mH赋值给sMainThreadHandler
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// 3.调用Looper.loop()方法，开启死循环，从MessageQueue中不断取出Message来处理
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
看样子，创建Handler还是需要调用Looper.prepare的，我们平常在主线程不需要手动调用，是因为系统在启动App时，就帮我们调用了。并且还需要调用Looper.loop方法，这个方法后面我们会讲到。所以使用Handler通信之前需要有以下三步：
- 调用Looper.prepare()
- 创建Handler对象
- 调用Looper.loop()
那按照这个套路，我们完善下之前的代码，其实就是在子线程中创建Handler之前调用Looper.prepare()，之后调用Looper.loop()方法，如下：
// 创建一个子线程，并在子线程中创建一个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();
这时候再点击按钮，在主线程向子线程发送消息，log如下图。
image.png
现在就可以使用Handler在主线程向子线程发送消息了,且可以看到，是在子线程中处理消息的。
3. Handler机制原理
Handler机制，主要牵涉到的类有如下四个，它们分工明确，但又相互作用
- Message：消息
- Hanlder：消息的发起者
- Looper：消息的遍历者
- MessageQueue：消息队列
下面我们从Handler的套路，来一一分析他们的作用
3.1 Looper.prepare()
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
// 规定了一个线程只有一个Looper，也就是一个线程只能调用一次Looper.prepare()
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
// 如果当前线程没有Looper，那么就创建一个，存到sThreadLocal中
sThreadLocal.set(new Looper(quitAllowed));
}
从上面的代码可以看出，一个线程最多只有一个Looper对象。当没有Looper对象时，去创建一个Looper，并存放到sThreadLocal中，sThreadLocal是一个static的ThreadLocal对象，关于它的详细使用，以后有机会再介绍，这里只要知道，它存储了Looper对象的副本，并且可以通过它取得当前线程在之前存储的Looper的副本。如下图：
ThreadLocal.png
接下来看Looper的构造方法：
private Looper(boolean quitAllowed) {
// 创建了MessageQueue，并供Looper持有
mQueue = new MessageQueue(quitAllowed);
// 让Looper持有当前线程对象
mThread = Thread.currentThread();
}
这里主要就是创建了消息队列MessageQueue，并让它供Looper持有，因为一个线程最大只有一个Looper对象，所以一个线程最多也只有一个消息队列。然后再把当前线程赋值给mThread。
MessageQueue的构造方法没有什么可讲的，它就是一个消息队列，用于存放Message。
所以Looper.prepare()的作用主要有以下三点
- 创建Looper对象
- 创建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就在子线程中创建Handler时报的错误嘛。的确，当我们没有调用Looper.prepare()，则当前线程中是没有Looper对象的。
然后，让Handler持有得到的Looper对象的MessageQueue和设置处理回调的Callback对象（最开始图中的回调方法2）。
到这里，默认的Handler的创建过程就结束了，主要有以下几点
- 创建Handler对象
- 得到当前线程的Looper对象，并判断是否为空
- 让创建的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;
// 无关代码
......
// 死循环
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，其实就是发送消息的Handler，这里就是调用它的dispatchMessage方法
msg.target.dispatchMessage(msg);
// 回收Message
msg.recycleUnchecked();
}
}
首先还是判断了当前线程是否有Looper，然后得到当前线程的MessageQueue。接下来，就是最关键的代码了，写了一个死循环，不断调用MessageQueue的next方法取出MessageQueue中的Message，注意，当MessageQueue中没有消息时，next方法会阻塞，导致当前线程挂起，后面会讲到。
拿到Message以后，会调用它的target的dispatchMessage方法，这个target其实就是发送消息时用到的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以后，进行分发处理。
首先，判断msg.callback是不是空，其实msg.callback是一个Runnable对象，是Handler.post方式传递进来的参数，后面会讲到。而hanldeCallback就是调用的Runnable的run方法。
然后，判断mCallback是否为空，这是一个Handler.Callback的接口类型，之前说了Handler有多个构造方法，可以提供设置Callback，如果这里不为空，则调用它的hanldeMessage方法，注意，这个方法有返回值，如果返回了true，表示已经处理 ，不再调用Handler的handleMessage方法；如果mCallback为空，或者不为空但是它的handleMessage返回了false，则会继续调用Handler的handleMessage方法，该方法就是我们经常重写的那个方法。
关于从MessageQueue中取出消息以后的分发，如下面的流程图所示：
Message分发.png
所以Looper.loop的作用就是：从当前线程的MessageQueue从不断取出Message，并调用其相关的回调方法。
2.4 发送消息
使用Handler发送消息主要有两种，一种是sendXXXMessage方式，还有一个postXXX方式，不过两种方式最后都会调用到sendMessageDelayed方法，所以我们就以最简单的sendMessage方法来分析。
image.png
image.png
我们先来看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其实就是创建时的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);
}
主要实现是调用enqueueMessage来实现的，看看该方法：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
// 把当前Handler对象，也就是发起消息的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发送的消息加入到MessageQueue，供Looper去取出来处理。我们记下来看看MessageQueue的enqueueMessage方法：
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
// 一个Message，只能发送一次
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已经使用了
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 {
// 根据需要把消息插入到消息队列的合适位置，通常是调用xxxDelay方法，延时发送消息
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是否已经使用过了，如果使用过，则直接抛出异常，这是可以理解的，如果MessageQueue中已经存在一个Message，但是还没有得到处理，这时候如果再发送一次该Message，可能会导致处理前一个Message时，出现问题。
然后，会判断when，它是表示延迟的时间，我们这里没有延时，所以为0，满足if条件。把消息插入到消息队列的头部。如果when不为0，则需要把消息加入到消息队列的合适位置。
最后会去判断当前线程是否已经阻塞了，如果阻塞了，则需要调用本地方法去唤醒它。
以上是sendMessage的全部过程，其实就是把Message加入到MessageQueue的合适位置。那我们来简单看看post系列方法：
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
// 构造一个Message，并让其callback执行传来的Runnable
Message m = Message.obtain();
m.callback = r;
return m;
}
可以看到，post方法只是先调用了getPostMessage方法，用Runnable去封装一个Message，然后就调用了sendMessageDelayed，把封装的Message加入到MessageQueue中。
所以使用handler发送消息的本质都是：把Message加入到Handler中的MessageQueue中去。
4. 总结
我们再来总结下Handler消息机制主要的四个类的功能
- Message:信息的携带者，持有了Handler，存在MessageQueue中，一个线程可以有多个
- Hanlder:消息的发起者，发送Message以及消息处理的回调实现，一个线程可以有多个Handler对象
- Looper:消息的遍历者，从MessageQueue中循环取出Message进行处理，一个线程最多只有一个
- MessageQueue:消息队列，存放了Handler发送的消息，供Looper循环取消息，一个线程最多只有一个
再来看看开始的结构图，是不是一目了然了：
Handler机制.png
6. 课后题
- Android中，有哪些是基于Handler来实现通信的？
- 处理Handler消息，是在哪个线程？一定是创建Handler的线程么？
- 消息是如何插入到MessageQueue中的？
- 当MessageQueue没有消息时，它的next方法是阻塞的，会导致App ANR么？
- 子线程中可以使用Toast么？
- Looper.loop()是死循环，可以停止么？
- Handler内存泄露怎么解决？
篇幅问题，放到下一篇详解，点击Handler课后题
