Android Handler 运行机制
什么是 Handler？有什么用？
在 android 应用开发中经常用到 Handler ，大概知道 Handler 常被用来处理线程间通信，比如：在子线程中处理某个逻辑后通过 Handler 发送消息的方式，切换回 UI 线程更新界面
Handler 到底是什么呢？总能听到最傻瓜式的问法，那么就来简单回答一下：Handler 不是一个具体的对象，暂且说是一套解决方案吧，在 Android 中处理消息 （Message）的一套方案。
我们通过研究 Handler 的运行机制来了解 android 的消息机制
什么是 Handler 运行机制？
这里需要引入几个概念和名词 Message / MessageQueue / Looper
以下请允许我用不太恰当地方式简单解释一下这几个概念
Message : 消息
MessageQueue : 消息队列
Looper : 无限循环地从队列中获取消息交给 Handler
Handler : 发送消息，处理消息
如果有人问你， Handler 运行机制 是怎么样的，你就告诉他：
Handler 发送消息(Message) 到消息队列中(MessageQueue) ，Looper 通过无限循环的方式不断向消息队列中获取新添加的消息 然后交给 Handler ，最终消息回到 Handler 中被处理
（平常开发中）由于 Handler 创建在主线程，处理消息的方法也运行在主线程，因此上述中消息被 Looper 交回给 Handler 的时候就实现了“线程切换”
喔~这个6，这个6，这个思想非常棒，仔细想想在子线程中做了一堆操作，什么添加消息到队列，我们不管，只认准最后 Looper 把消息交回给了 Handler ，又因为 Handler 运行在主线程中，因此最后处理消息时就在主线程了（根本原因是创建Handler 的 Looper 默认使用主线程的 Looper ）
理论往往是抽象枯燥的，我们总希望通过熟悉的代码来慢慢体会，来看下日常开发中常用Handler使用场景，在子线程中处理耗时逻辑，然后再发送消息到主线程中更新UI
在主线程中创建Handler处理类
class MyHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
Log.e("tag", "thread name:" + Thread.currentThread().getName());
//更新UI
break;
}
}
}
MyHandler myHandler = new MyHandler();创建线程，处理耗时逻辑，然后发送消息
new Thread("t1") {
@Override
public void run() {
//耗时操作
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Message message = Message.obtain();
message.what = 1;
//发送消息
myHandler.sendMessage(message);
}
}.start();这里可以看到，我们在主线程（activity运行在主线程中）创建Handler，然后创建一个子线程 t1 ，在 t1 中处理耗时逻辑，再通过 sendMessage() 发送消息，就是这么一个简单的代码，能够实现”线程切换”的效果，到底是怎么实现的呢？
开发中我们能接触到的只有 Handler ，对于 MessageQueue 和 Looper 这两个概念比较陌生，就上述的例子中也完全没有体现这些字眼，但是对于 Handler 的运行他们起到了不可缺少的重要作用。
Handler 通过 sendMessage 发送消息后，将 Message 发送到了哪里呢？ 又是怎么拿到这些 Message 的呢？
MessageQueue 消息队列工作原理
MessageQueue 翻译为消息队列。简单的说就是装载消息(Message) 的容器。容器？那不是很简单，只要负责 添加 和 读取（移除） 内容就好了。
当 Handler 通过 sendMessage 方法发送 Message 时， MessageQueue 就会调用 enqueueMessage 方法把这条消息添加到自身容器中。然后呢？然后就放着呗，等着别人来取，当有人来取 Message 的时候，通过 next 方法取出一条消息并将消息从自身容器中移除，这就是消息队列的工作职责
这里注意，虽然叫做消息队列，但是内部实现并不是用队列，而是单链表的数据结构来维护消息列表
MessageQueue : 添加消息到队列 enqueueMessage
上面说 sendMessage 时 MessageQueue 就会调用自身的 enqueueMessage 将消息添加到自身容器，怎么实现的呢？Handler 和 MessageQueue 两者又是怎么关联起来的？这时候我们就需要通过阅读一下源码啦
等一下，别走啊，这源码很简单的，不用一头扎入，看个大概思路就行
我们知道 Handler 发送消息的方法有很多，先不管，需要知道的是最后调用的都是同一个 sendMessageAtTime()
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);
}这个就是 Handler 的 sendMessageAtTime 方法的源码啦，很简单，将一个 mQueue （特别注意这个 mQueue）赋值给 MessageQueue。 MessageQueue 如果为空，抛异常，不为空当做一个参数传递给 enqueueMessage （Handler 的方法），恩，这里问题不大，很普通的写法，接着看看 Handler 的 enqueueMessage 方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}丢掉前面无关的代码，直接聚焦 queue.enqueueMessage(msg, uptimeMillis) 这行代表表示，最终调用了 MessageQueue 的 enqueueMessage 方法将消息添加进队列
到这里已经很清晰可以看到 MessageQueue 将消息加入队列的逻辑了，不用看都知道， enqueueMessage 具体实现肯定是操作链表添加内容
怎么样？是不是很简单，很清晰的看到
Handler 调用 sendMessage 方法时 MessageQueue 会通过 enqueueMessage 方法将 message 添加到自身容器中
嗯，细心的同学或许就会问了，这个 MessageQueue 是哪里来的，你突然引入一个 MessageQueue 然后就开始添加 消息了，也没说他是哪里崩出来的呀
回到刚才那个 sendMessageAtTime() 方法，第一行代码出现：MessageQueue queue = mQueue;
原来 MessageQueue 是通过 mQueue 赋值的。
在 Handler 类中搜索 mQueue ，找啊找啊，最后在 Handler 构造方法中找到它
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}没错就是它 mQueue ，它是通过 looper.mQueue 得到的
而且我们通过其他的构造函数发现 Handler 的所有构造函数最终都是调用这个方法，也就是说，我们在创建 Handler 的时候就创建了这个 MessageQueue
soga 原来 MessageQueue 是通过 Looper 得到的，那 Looper 又是什么？乘胜追击看看这个 Looper 是什么。
Looper 工作原理
Looper 在 android 消息机制中扮演着 循环从队列中获取消息的角色，就是说它会无限循环的查询 消息队列中是否有新的消息，如果有就获取到这个消息，然后交给Handler，如果没有就阻塞在那里
先看看 Looper 的构造方法
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}在 Looper 构造方法中，创建了一个 MessageQueue 即消息队列，然后获取当前线程保存起来。
我们知道 Handler 工作需要 Looper 的支持，如果没有 Looper 的线程中使用 Handler 就会报错，那如何为一个线程创建一个 Looper 呢？ 很简单， 通过 Looper.prepure() 就可以为一个线程创建 Looper ，接着调用 Looper.loop() 来开启消息循环。示例如下
new Thread("t1") {
@Override
public void run() {
Looper.prepare();//创建Looper
Handler handler = new Handler();//Handler 使用
Looper.loop();//开启消息循环
}
}.start();Looper.prepare() 创建 Looper 很简单不说了，下面有个 Looper.loop() 开启消息循环，这个是 Looper 的重心啦，看看怎么实现的
loop() 的源码比较多，不必每一行都去分析，我们通过剔除一些代码，让源码看起来简洁一些，这样就不会掉进源码的漩涡中不能自拔。
public static void loop() {
//剔除代码
final MessageQueue queue = me.mQueue;
//...
for (;;) {
Message msg = queue.next(); // 调用 MessageQueue 的 next 方法获取 Message
if (msg == null) {
// No message indicates that the message queue is quitting.
// msg == null 表示 MessageQueue 正在退出（调用了quit等方法）
return;
}
//剔除代码
try {
// msg.target 就是发送消息的Handler，因此这里将消息交回 Handler
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
//剔除代码
}
}前面说了，Looper 通过无限循环的方式获取 消息队列 中的消息
for (;;) 死循环从消息队列中获取 消息 ，当 msg == null 跳出循环。
通过调用 Looper 的 quit() 或者 quitSafely() 让 Looper 退出循环
// quit
public void quit() {
mQueue.quit(false);
}
// quitSafely()
public void quitSafely() {
mQueue.quit(true);
}我们看到 Looper 的 quit() 或者 quitSafely() 方法调用的是 MessageQueue 的 quit() 方法，使得 msg 返回 null 从而让 Looper 退出循环。这两个方法的区别是： quit 是直接退出 Looper; quitSafely 会设置一个退出标识，等到队列中的消息都处理完了，再安全退出。Looper 退出后 Handler 就无法发送消息了
loop() 中 获取到消息通过 msg.target.dispatchMessage(msg) 将消息 message 交给 Handler 的 dispatchMessage 方法处理，这也就是为什么 能够实现线程切换的关键所在，因为 Handler 运行在主线程
MessageQueue : 获取消息 next
在 Looper.loop() 中我们看到通过 MessageQueue 的 next 方法获取队列中的消息
Message next() {
// 剔除代码
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
// 阻塞
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
//存在消息，未到执行时间
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
//存在消息，获取消息返回
// Got a message.
mBlocked = false;//表示目前没有阻塞
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;//将 msg 从 MessageQueue 链表中移除
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {
// 没有消息处理 进入阻塞
// No more messages.
nextPollTimeoutMillis = -1;
}
// MessageQueue 退出 返回 null
// Process the quit message now that all pending messages have been handled.
if (mQuitting) {
dispose();
return null;
}
//剔除代码
}
//剔除代码
}
}next 通过 for (;;) 死循环不断获取新增的消息，返回给 Looper，如果没有消息，就一直阻塞在这里，当有新消息到达，next 会返回这条消息，并且从链表中删除
Handler 工作原理
Handler 的工作原理就比较简单啦，主要负责 发送消息 和 处理消息
发送消息 主要通过一些列 post 和 send 方法来实现，具体可以查查接口文档，通过源码可以看到最终都是调用 sendMessageAtTime()
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);
}sendMessageAtTime() 的源码很简单，调用 MessageQueue 的方法 enqueueMessage 将 Message 添加到消息队列，同时 msg.target = this; 将 Handler 自身赋值给了 msg.target
可以发现， Handler 发送的消息过程是向消息队列添加一条消息，这时 MessageQueue 的 next 方法就会将这条消息返回给 Looper，Looper 收到消息后开始处理，最终通过 msg.target.dispatchMessage(msg); 将消息交给 Handler ，即 Handler 的 dispatchMessage 方法会被调用，这时 Handler 就进入了消息处理阶段
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}Handler 处理消息的过程：
首先检查 Message 的 callback 是否为 null。 不为 null 直接通过 handleCallback 来处理消息。Messsage 的 callback 是一个 Runnable 对象，也就是 Handler 的 post 系列方法所传递的 Runnable 参数。 handler.post(runnable);
handleCallback
private static void handleCallback(Message message) {
message.callback.run();
}然后检查 mCallback 是否 null。不为 null 直接通过 mCallback 的 handleMessage 处理消息。mCallback 是一个接口，定义如下
/**
* Callback interface you can use when instantiating a Handler to avoid
* having to implement your own subclass of Handler.
* //不需要通过一个 Handler 的子类，就可以创建一个 Handler 的实例
*
* @param msg A {@link android.os.Message Message} object
* @return True if no further handling is desired
*/
public interface Callback {
public boolean handleMessage(Message msg);
}接口注释说明了，通过 Callback 可以不通过 Handler 的子类就能实现一个 Handler 的实例。
不理解？没事，代码解释。开发日常我们用的比较多的是通过继承 Handler 实现一个 Handler 的子类来实现
class MyHandler extends Handler {
@Override
public void handleMessage(Message msg) {
//处理消息
}
}而使用 Callback 接口时
Handler handler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
return false;
}
});当我们不想派生子类时，就可以通过 Callback 的方式实现
OK，再回过头来看看 Handler 运行在主线程 这个问题。
其实 Handler 运行在哪个线程，是由创建 Handler 的 Looper 决定的，简单看个例子（onCreate()方法中）
new Thread("t1") {
@Override
public void run() {
Looper.prepare();
looper = Looper.myLooper();
Looper.loop();
}
}.start();
SystemClock.sleep(100);//确保成功获取到 looper
Handler handler = new Handler(looper, new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
Log.e("Ruffian", "Thread Name:" + Thread.currentThread().getName());
return false;
}
});
Message mess = Message.obtain();
mess.what = 1;
handler.sendMessage(mess);解释一下代码：创建一个子线程 t1 ，为这个线程创建 Looper （Looper.prepare();），然后获取 t1 线程的 Looper 用于创建 Handler
在 Handler 的 handleMessage 中处理消息，打印 Handler 所在的线程，结果为： t1
那为什么默认创建的 Handler 就是运行在主线程的？看下面的例子
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Message mess = Message.obtain();
mess.what = 1;
Handler handler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
Log.e("Ruffian", "Thread Name:" + Thread.currentThread().getName());
return false;
}
});
handler.sendMessage(mess);
}
在 Handler 的 handleMessage 中处理消息，打印 Handler 所在的线程，此时，结果为： main
看一下 Handler 构造方法的代码（在不指定Looper的时候）
public Handler(Callback callback, boolean async) {
//剔除代码
mLooper = Looper.myLooper();//获取当前线程Looper
//剔除代码
}通过代码可以看出，在创建 Handler 不指定 Looper 时，Handler 的构造方法会获取当前线程的 Looper ，由于activity 的 onCreate() 方法运行在主线程，所以 Looper 也属于主线程，通过此 Looper 创建的 Handler 当然也运行在主线程啦~
由此可以验证 Handler 运行在哪个线程由 创建 Handler 的 Looper 属于哪个线程决定
讲完…