前言
本文以Android源码为基础做出一定的分析，并且最主要的目的是让读者对消息机制有一个的认知，所以文章分为两部分。第一部分只讲完整的消息流程是怎样的，对一些细节部分暂时忽略，第二部分再讲，但是我保证忽略的细节不影响理解消息机制的内容。不过我很反感一顿乱贴源码的做法，所以我在贴出的源码中都进行了一定的注释与省略方便阅读。还有就是既然题目叫浅入浅出，所以在底层原理方面讲的并不是很深入，我相信这样大家理解起来肯定非常轻松，请放心食用。
简述
首先，我先介绍一下消息机制的世界，Android的消息机制主要由Handler、Looper、MessageQueue这三个类负责。并且要想完整的走完发送消息并进行处理这一流程这三个对象缺一不可。看到这里可以有读者有疑问了，既然缺一不可，为什么我平时使用的时候只用了Handler对象也能完成消息的传输？
想到这里可能有的同学和我一样会猜应该是在Handler的构造函数里面创建了MessageQueue和Looper对象。但有经验且机智的同学可能已经发现了猜想的不对了，那就是为什么在子线程中创建Handler对象会抛异常？这个问题先留着，我稍后再讲，同时也希望读者可以猜一猜,提示一下，答案肯定不是子线程不能创建Handler对象，因为子线程是可以创建Handler对象的。
然后继续讲消息机制的世界，其中Handler负责消息（就是Message对象）的发送与消息的处理。而消息就是发送到了消息队列（也就是MessageQueue对象）中保存了下来。然后Looper对象会一直循环的去获取消息队列中的消息，没有就阻塞，有的话就将消息取出，最后再由Handler进行处理，以此实现在线程间传输消息。当然这只是大概流程，下面由我来细细说明。
ThreadLocal
在开始之前，先介绍一个家伙：ThreadLocal。它在消息机制的建设中有着不可磨灭的功劳，我先介绍介绍它，以防后面它出场的时候你不认识。它作用很简单就是保存当前线程的Looper对象，数据结构可以简单理解为Map<Thread,Looper>(注意:实际数据结构并不是这样!!!)，key为当前线程，value为当前线程创建的Looper对象。
被偏爱的主线程
上面提到了消息传递需要Handler、Looper、MessageQueue这三位大哥的配合，但主线程却只需要创建Handler对象就可以了，为什么呢？答案就是在主线程被创建时就会创建一个Looper对象，请往下看：
//第一步
public static void main(String[] args) {
...
Looper.prepareMainLooper();//跳到下面第二步
...
//意义为消息的取出，这一行代码后面再详将，这行代码的作用就是开始无限循环的
//读取MessageQueue里面的消息
Looper.loop();
...
}
//第二步
public static void prepareMainLooper() {
prepare(false);
...
}
//第三步
private static void prepare(boolean quitAllowed) {
//这一行代码就是将以线程为Key，将Looper对象保存在ThreadLocal
sThreadLocal.set(new Looper(quitAllowed));
}
//第四步，看Looper的构造方法
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
...
}
简单解释一下，在主线程创建之时，Looper对象就被创建了，而在Looper的构造函数中又会创建MessageQueue对象。再接着将Looper对象保存在sThreadLocal中，最后执行Looper.loop()开启消息循环。所以，可以说主线程就是含着金汤匙出生的，天生就自带Looper与MessageQueue对象。
消息发送与接收
首先，我们最常见的使用Handler的方法就是用来刷新UI，使用流程大致如下：
1 private Handler handler = new Handler(){//主线程创建
2 @Override
3 public void handleMessage(Message msg) {
4 //这里对消息进行处理，常见用来更新UI
5 }
6 };
7 handler.sendMessage(message); //子线程发送
那么我们一步步来解析，看看这些步骤都做了哪些事情，先从Handler handler = new Handler()这里开始：
//第一步
8 public Handler() {
9 this(null, false);
10 }
//第二步，为了理解方便，部分源码忽略
11 public Handler(Callback callback, boolean async) {
...
12 mLooper = Looper.myLooper(); //看第三步
...
mQueue = mLooper.mQueue;// mQueue即为MessageQueue对象
...
}
//第三步
public static @Nullable Looper myLooper() {
return sThreadLocal.get();//此时将之前保存的Looper对象取出
}
简单梳理一下，首先获得在主线程创建的Looper与MessageQueue对象，并保存在Handler中。然后我们再看看发送函数中发生了什么事情：
//第一步
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;
...
return enqueueMessage(queue, msg, uptimeMillis);
}
//第四步
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//这一行代码很重要，即把创建的Handler对象保存在了msg中，为后面消息的处
//理埋下了伏笔
msg.target = this;
...
return queue.enqueueMessage(msg, uptimeMillis);
}
//第五步,此时已经开始执行MessageQueue中的方法，消息的插入
boolean enqueueMessage(Message msg, long when) {
...//这部分都先不看，可以先简单的理解为将消息保存在了MessageQueue中，后面会详细解释
}
到这里消息的发送就完结了，简单整理一下，首先将创建的Handler对象保存在了Message对象中，相当于你寄快递，然后你还是快递的一部分。最后就是将消息保存在消息队列中了。前面提到了主线程创建中会创建Looper对象，并开始循环的读取消息队列中的信息。即代码 ：Looper.loop();下面看一看这行代码做了什么事。
//第一步
public static void loop() {
final Looper me = myLooper();
...
final MessageQueue queue = me.mQueue;
for (;;) {
Message msg = queue.next(); //从队列中取出消息， 这里细节后面再讲
...
try {
//首先这里的msg.target就是之前存入的Handler对象（之前提过）
msg.target.dispatchMessage(msg);
...
} finally {
...
}
...
}
}
//第二步
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
...
} else {
...
//看到这个方法不知道你激动了没，反正我是很激动了
handleMessage(msg);
}
}
//最后一步
private static Handler handler1 = new Handler(){
@Override
public void handleMessage(Message msg) {
Log.i(TAG, "这时就调用到了这里，一个完整的流程走完了");
}
};
此时，消息循环就此结束了。
第一部分总结
从上面的内容中一个消息机制的完整流程就结束了，这里再用文字总结一下。首先在app打开时就会在主线程中创建Looper和MessageQueue对象，然后保存在ThreadLocal中，以便后面取出，接着开启循环读取消息，Looper会一直读取MessageQueue中的消息。然后，创建Handler对象，并将之前创建的Looper和MessageQueue对象保存在Handler对象中。接着发送消息，先将handler对象保存在message中，并将message放入MessageQueue中。由于Looper对象一直在读取MessageQueue中的消息，所以此时发现有了一条消息会将消息取出，然后再取出消息中的Handler对象，最后再执行覆写的handleMessage()就完成了消息传输了。
Message的插入
在这里先补充一下，Message的数据结构为一个单链表，上一条Message中保存有这一条的Message对象。在第一部分中涉及消息插入的代码没讲，下面来简要分析一下：
boolean enqueueMessage(Message msg, long when) {
...
synchronized (this) {
...
msg.when = when;//when代表延时多久插入消息
Message p = mMessages;//mMessages代表当前待处理消息
if (p == null || when == 0 || when < p.when) {//满足条件将msg设为待处理消息
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
} else {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue
Message prev;
for (;;) {//遍历消息链表
prev = p;
p = p.next;
if (p == null || when < p.when) {//当存在空消息或者此条消息为此时最新时
break;
}
}
//将msg插入到mMessages中
msg.next = p;
prev.next = msg;
}
...
}
return true;
}
消息的插入大致如上所示。就是一个链表的插入过程，其中mMessages就是代表这个消息链表了。建议在看的时候可以在纸上画一下，这样理解起来更简单。
Message的取出
同样的，消息的取出的代码第一部分也没讲，下面我们来看一下：
Message next() {
...
for (;;) {//循环读取消息
...
synchronized (this) {
// Try to retrieve the next message. Return if found.
Message prevMsg = null;
Message msg = mMessages;
...
if (msg != null) {
if (now < msg.when) {
...
} else {
...
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
...
return msg;
}
} else {
...
}
...
}
仔细看了一下，好像也没什么好说的，就是简单的从链表中取出第一条信息。
子线程中使用Handler
现在我们试一下在子线程中创建Hangler对象会怎么样？
答案很明显，app会崩溃。
之前说过了，消息机制需要Handler、MessageQueue、Looper这三个对象，而子线程可不像主线程那样特殊会自动创建MessageQueue、Looper对象，所以app崩溃是再正常不过的事了。
那我们来看一下异常信息， Can't create handler inside thread that has not called Looper.prepare()。
意思为：没有调用Looper.prepare()的话在子线程是不能创建Handler对象的。
那我们就来看一下这个方法做了什么事：
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));
}
看到没，很简单。就是创建Looper和MessageQueue对象，并将Looper对象保存在ThreadLocal对象中。
那现在就可以在子线程中使用Handler了，不过要想完成消息的传递还差一步就是执行Looper.loop()开启循环的在消息队列中读取消息。
心得体会
在学习Android消息之前就为自己定了一个目标，学完后写一篇博客。但万万没想到认真的写一篇技术博客这么费劲。从年前我就开始写了，结果写到现在才完成，虽然还有一些可以拓展的地方，但鉴于篇(xiang)幅(yao)原(tou)因(lan)就不讲了。不过，在写这篇文章期间也让我对Android的消息机制有了更深刻的印象。总的来说还是蛮值得的。若有有缘之人看到这篇文章有异议或者觉得有什么地方我没说清楚的话欢迎留言告诉我一下，大家一起学习进步。
