带着问题分析Android Handler
背景
Android 中的 Handler 在Android 中的重要性，想必不用多说了。网上也有一堆分析Handler 的文章，说实话写的都很不错，看完也会觉得受益匪浅，但是在面试的时候面试官问到Handler 机制的时候总有那么一两个问题答不上来，这是为什么呢？究其原因是因为自己没看过源码，或者对源码的理解不够。本文就结合在面试中被问到的问题从源码中去找答案，并做一个总结。
面试中常碰到哪些问题
- Handler 是如何工作的？
- Handler 为什么会导致内存泄露？
- 一个Activity 中可否有多个Handler？
- 在一个新的线程中如何新建新Handler？
- 一个线程中可否存在多个Handler？
- Handler 中send 方法和post方法有什么区别？
- postDelay 方法中 delay 的时间存在哪？
- 一个线程中可否存在多个Looper？
- ThreadLocal 这个类的作用是什么？
- 往MessageQueue 中插入消息是否有上限？
- Looper 的loop 方法是阻塞方法，为什么不会造成ANR？
以上这些问题经常会出现在面试当中，如果只是单纯的看其他的Handler 分析的文章，有一些问题可能还是一知半解，或者根本答不上来。现在我将在本文中结合源码对以上问题一一进行解答。
解答
Handler 是如何工作的？
我们先从Handler 的基本使用入手。
伪代码：
MainActivity.java
// Acricity中 新建Handler 实例
final Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
if (msg.what == 1) {
// TODO: 主线程处理消息
}
}
};
new Thread(new Runnable() {
@Override
public void run() {
// TODO: 子线程耗时操作
handler.sendEmptyMessage(1);
}
}).start();
我们来看看new Handler() 都做了些什么。handler.sendEmptyMessage(1)又是怎么让消息回到handleMessage(Message msg)方法中的。
先来看new Handler()
Handler.java
public Handler() {
this(null, false);
}
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
klass.getCanonicalName());
}
}
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
构造方法很简单，主要的就三行
mLooper = Looper.myLooper();
mQueue = mLooper.mQueue;
mCallback = callback; //注意这里callback 为null.
就是初始化了 mLooper 和mQueue，这样，一个handler 实例就构造出来了。
接着我们看handler.sendEmptyMessage(1)
Handler.java
public final boolean sendEmptyMessage(int what){
return sendEmptyMessageDelayed(what, 0);
}
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
这里先是拿到一个 Message,what赋值给msg.what,继续将这个Message发送出去，往下看。
Handler.java
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 queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
这里主要是后面两个方法，先是拿到mQueue 这个对象，然后调用queue.enqueueMessage(msg, uptimeMillis);这个方法，将这条Message 添加到mQueue 中。注意这句msg.target = this;,这里的this 指的是当前handler 这个对象，后面会用到。
到这里handler 发送消息的部分就完成了。
是不是有疑问，这里只有发送消息却没有处理消息啊？别着急，前面Handler 的构造方法里面有一个mLooper，这个mLooper 是什么呢，又是做什么用的呢？回到Handler 的构造方法中， mLooper 是通过Looper 的静态方法进行初始化的，打开Looper这个类看看。
Looper .java
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
这里通过 sThreadLocal.get();方法获取到的Looper ，先不管sThreadLocal这个对象是什么，既然有get(),肯定有一个地方调了set()方法把Looper设置进去了。由于Activity 中的Handler 有点特殊，Android 系统在启动Activity 的之前就调用了Looper.prepareMainLooper();和Looper.loop();,看看这两个方法。
先看prepareMainLooper()
Looper .java
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
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));
}
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
这里就是调用了prepare()方法，并调用了sThreadLocal.set(new Looper(quitAllowed)); 这里new 了一个Looper 对象，在这个Looper 里面又new 了一个MessageQueue，前面Handler 的构造方法里面初始化的mQueue 就是这里的这个MessageQueue 了。到这里Looper 有了，MessageQueue 有了，Handler 也有了。
前面说了Android 系统在启动Activity 的之前就调用了Looper.prepareMainLooper();和Looper.loop();
我们再看看Looper.loop();里面的代码。
代码有点长，我删除了无关紧要的代码。
Looper .java
public static void loop() {
final Looper me = myLooper();
...
final MessageQueue queue = me.mQueue;
...
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
...
msg.target.dispatchMessage(msg);
...
msg.recycleUnchecked();
}
}
可以看到，这里先是拿到looper，再取出looper中的MessageQueue, 然后进入一个死循环中，调用queue.next();取出queue中的Message（有Message则取出，无则阻塞）。然后调用msg.target.dispatchMessage(msg); 这里的msg.target前面讲了是当前的Handler 对象，所有这里实际调用的是Handler 的 dispatchMessage(msg);，最终代码将执行到handleMessage(Message msg)中。于是整个消息分发流程结束。
总结一下，Handler 的工作方式就是，先是有一个Looper 和 一个MessageQueue， Looper 一直去查询MessageQueue 中是否有Message。当Handler 发送一条Message，该条Message 就会被添加到MessageQueue中，Looper 查询MessageQueue 中存在Message并取出来，再将这个Message 交给Handler 去处理。
几个类的作用
Handler: 发送Message 并处理Message.
MessageQueue: 维护Message 队列，插入和取出Message.
Looper : 轮询 MessageQueue 中的Message，取出Message 并交由Handler 处理。
一个Activity 中可否有多个Handler？
答案是可以的，在一个Activity 中你想new 几个Handler 就new 几个。在Handler 的enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)方法中
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
从msg.target = this;这句代码也可以看出，使用哪个Handler 对象发送消息，最终消息还是会回到发送该消息的Handler 中处理。
一个线程中可否存在多个Handler？
同上。
在一个新的线程中如何新建新Handler？
先来写段代码测试一下直接在一个新的线程中new 出一个Handler 看看会发生什么。
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_handler_test);
// 新开一个线程
new Thread(new Runnable() {
@Override
public void run() {
// 线程中创建Handler
Handler handler = new Handler();
}
}).start();
}
简单的代码，点击运行，程序直接Crash了，下面是错误信息。
java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
意思是在线程中没有调用Looper.prepare() 就不能创建handler 。
既然这样我们就在创建Handler之前调一下Looper.prepare() 看看。
new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
Handler handler = new Handler();
Looper.loop();
}
}).start();
点击运行，程序能正常运行了。上面的代码在run()结尾的地方加了Looper.loop()这句代码，有这句代码才能使整个Handler 机制生效。下面来分析一下到底为什么要这么写。
回到Handler 的构造方法中,具体代码就不贴了（前面贴过了），有这么几句，
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
在Handler 的构造方法中，通过Looper.myLooper()获取到一个空的Looper，所以这里抛出了一个异常。
再看下Looper.prepare()和 Looper.myLooper()的代码
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));
}
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
可以看到prepare()方法里面初始化了一个Looper对象，并把它set 到sThreadLocal这个对象里面，因此在通过Looper.myLooper()之前必须先调用Looper.prepare()。
前面还有一句代码没说 Looper.loop(),为什么要调用这个？
因为Looper.prepare()和Handler handler = new Handler()只是初始化了Looper和Handler，也就是只是将消息循环机制的条件准备好了，整个机制还未真正起作用，真正使整个消息机制起作用的就是 Looper.loop()这句代码（前面贴过代码这里就不再贴了）。
因此要在一个新的线程中使用Handler，必须先在这个线程中调用 Looper.prepare()来初始化一个Looper，最后再调用Looper.loop()使整个Handler 机制生效。
那为什么在Activity 中可以不用调用 Looper.prepare()就能直接 new Handler 呢？前面已经说过了，由于Activity 中的Handler 有点特殊，Android 系统在启动Activity 的之前就调用了Looper.prepareMainLooper();和Looper.loop();，所以我们能在Activity 中直接使用Handler。
Handler 中send 方法和post方法有什么区别？
post() 方法最终还是调到send() 方法里面去的，这个没什么好说的，源码跟进去看一下就好了。
