说起Handler机制大家都不陌生，我也看过不少网上相关文章，都分析的很好，这里作为笔记，通过Handler,Looper,Message,MessageQueue这几个类，从源码中来解读从handler发送消息到接收到消息的过程。
通常，项目中都会用到Handler来发送一个异步消息，例如
Message msg = Message.obtain();
// msg.what = 0;
// msg.obj = obj;
// msg.arg1 = 1;
// ...
mHandler.sendMessage(msg);
又或者发送一个延时消息，例如
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
// TODO ...
Toast.makeText(MainActivity.this, "" , Toast.LENGTH_SHORT).show();
}
}, 1000);
一 、首先，我们来看看发送一个Message
进入sendMessage(msg)方法中，再一步步寻找
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 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);
}
最终进入到enqueueMessage方法，**msg.target = this; **这是绑定了当前Handler到发送的这个Message的target属性，最后调用的是MessageQueue的enqueueMessage方法，将消息放入到消息队列中。
其中，sendMessageAtTime方法中，MessageQueue queue = mQueue;赋值MessageQueue，在Handler构造方法中发现 mQueue = mLooper.mQueue;也就是说MessageQueue和Looper有关，我们再来看看Looper类。
先说说Looper是干什么的：Loop字面意思 回路 圈 。Looper类其实是用来循环取消息队列中消息的，类中有个两个主要的方法，prepare和loop方法，这里有的疑问好像要解开了，往下看
- 我们先来看看prepare方法：
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));
}
这里看到prepare方法是创建了Looper对象，同时设置给了sThreadLocal
sThreadLocal 是一个ThreadLocal对象。简单点说，就是当前Looper对象和当前的线程对象关联起来
仔细一看，"Only one Looper may be created per thread"，没错，每个线程只允许一个Looper对象！
进入Looper的构造方法，很显然，是在这里**MessageQueue被创建了 **
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
- 再来看看loop方法
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
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;
}
// 省略部分代码...
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
// 省略部分代码...
msg.recycleUnchecked();
}
}
源码中Message msg = queue.next(); // might block 可以看到这个方法可能会阻塞，也就是说，消息队列中没有消息的时候会阻塞，这里是从消息队列中取消息出来，调用个MessageQueue的next方法（具体的实现算法就不说了，包括入队的算法，涉及到native层）有兴趣的可以去看MessageQueue的源码。
然后往下 msg.target.dispatchMessage(msg);这句代码很好理解，前面我们说过在Handler发送消息的时候，会关联当前的Handler到所发送的Message的target属性，这里看到就是调用Handler的dispatchMessage()方法，
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
方法很简单，最终走的是handleMessage(msg);这行代码，点过去看到是调用空方法，就是我们需要重写的handleMessage方法。方法中我们还发现还可能会走handleCallback(msg);这行代码，其实，这就是另一种情况，是利用Handler发送延时消息最后走的方法，请往下看。
二、延时发送一条消息
从Handler的postDelayed方法看起
public final boolean postDelayed(Runnable r, long delayMillis)
{
return sendMessageDelayed(getPostMessage(r), delayMillis);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
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);
}
最后调用的还是和上面分析发送一条消息时一样，不过，这里多了一步getPostMessage，这是创建一个Message，并且赋值了Message的callback属性，也就是我们在postDelayed方法中传入的Runnable。
到这里，其实已经分析结束了，Looper和MessageQueue分析如上，在Handler的dispatchMessage方法中执行的是handleCallback(msg);因为msg.callback != null成立，最终，执行的是Message的callback，也就是我们传入的Runnable
private static void handleCallback(Message message) {
message.callback.run();
}
前面我们说了从Handler发送消息，然后进入消息队列，Looper再循环从MessageQueue中取出消息，最后执行相应的方法。细心的观众发现，Handler我们可以自己new出来，Message可以obtain，MessageQueue是由Looper中生成的，那么Looper又是怎么初始化的呢？
这里涉及到了ActivityThread这个类，我们都知道，ActivityThread中的main方法是整个应用进程的入口。
查看源码
public static void main(String[] args) {
// 省略代码...
Looper.prepareMainLooper();
// 省略代码...
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
看到了，Looper被初始化了，并且调用了loop,开始轮询消息队列。
解释一下prepareMainLooper()和prepare方法有什么不同，就是true|false的区别，表示是否可以被终止，因为这是主线程的Looper，所以false.
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
有点恍然大悟的感觉，为什么主线程中可以更新UI控件了，原来是系统主线程中会主动初始化一个Looper（我们如果手动再prepare就会报错，因为每个线程只允许一个Looper，也确保我们可以在不同的线程中创建各自的Handler，进行各自的通信而不会互相干扰）。那么，子线程中除了使用Handler或者调用runOnUiThread来更新UI控件，当然也可以前后加上Looper.prepare();和Looper.loop();，不过实际开发中不会这么用。