本文用于记录Android的消息机制，主要是指Handler的运行机制。部分内容参考自《Android开发艺术探索》，感兴趣可以阅读原书。
Handler是Android消息机制的上层接口，通过它可以轻松将一个任务从一线程切换到Handler所在的线程执行，如由子线程切换到主线程更新UI。具体来说有时候我们需要在子线程中执行耗时操作，当耗时操作结束时希望将UI更新，这时候我们就需要将线程切换到主线程了，也就是UI线程（因为Android不允许在子线程更新UI）。
Handler的运行需要底层MessageQueue和Looper的支持。MessageQueue也就是消息队列，它可以存储消息并以队列的形式提供插入消息和删除消息操作（注意：虽然叫消息队列，但它内部的存储结构并不是队列而是单链表）。Looper我们可以将它理解为消息循环，它会以无限循环的方式去消息队列中查找是否存在消息，有的话就对消息进行处理，没有的话就一直等待。
此外Looper中还有一个特殊的概念——ThreadLocal，ThreadLocal不是线程，它的作用是在每个线程中独立的存储数据。Handler在创建的时候，需要使用当前线程的Looper来构建消息循环系统，，那么如何获取当前线程的Looper呢？此时就要用到ThreadLocal，我们知道ThreadLocal可以在不同线程互不干扰的存储并提供数据，我们就可以通过ThreadLocal存储并获取每个线程的Looper了。需要注意的是除主线程外，其他线程默认是没有Looper的，想要使用Handler就必须为线程创建Looper。
Android的消息机制主要指Handler的运行机制以及Handler附带的MessageQueue和Looper的工作过程。系统之所以提供Handler，就是为了解决在子线程中无法更新UI的矛盾。试想一下，当我们通过网络请求从服务端拉取了一些数据需要更新在UI上，为了避免造成ANR，我们需要在子线程中执行网络请求操作，那该怎么访问UI呢，这时候我们就可以使用Handler，因为它允许我们将一个任务由某个线程切换到另一个线程执行。
延伸
Android的UI控件是线程不安全的，如果在多线程并发访问可能导致UI控件处于不可预期的状态。
首先加锁会让UI访问的逻辑变得十分复杂，其次加锁会降低UI的访问效率，因为加锁会阻碍某些线程的执行。
接着概述一下Android的消息机制，首先我们需要创建得到Handler，Handler创建时获取当前线程的Looper来构建内部的消息循环系统（除主线程外都需要手动创建Looper）。Handler创建完毕后，此时内部的Looper和MessageQueue就可以和Handler协调工作了。
ThreadLocal是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中才可以获取到存储到数据，对于其他线程数据是不可访问的。
当某些数据是以线程为作用域而且不同线程需要不同的数据副本时，就可以考虑使用ThreadLocal。如对于Handler来说，他需要获取当前线程的Looper，因为Looper的作用域是线程且不同线程有不同的Looper，此时我们就可以通过ThreadLocal实现Looper在线程内的存取。
ThreadLocal的另一个使用场景是实现复杂逻辑下的对象传递。比如监听器的传递，有时一个线程中的任务过于复杂——函数调用栈比较深或代码入口多样，我们需要监听器能够贯彻整个线程的执行过程，这时候就可以使用ThreadLocal让监听器作为一个全局变量而存在，在线程内部只需通过get方法获取监听器即可。
上面介绍了这么多理论知识，接下来我们通过一个具体的代码实例来加深理解，在这个实例中我们会创建一个Integer类型的ThreadLocal对象，接着在主线程和三个子线程中分别设置并输出它的值：
//创建ThreadLocal
ThreadLocal<Integer> booleanThreadLocal=new ThreadLocal<>();
booleanThreadLocal.set(1);//设置主线程的值为1
System.out.println("ThreadLocal的值为："+booleanThreadLocal.get());
//子线程1
new Thread(new Runnable() {
@Override
public void run() {
booleanThreadLocal.set(2);//设置子线程1的值为2
System.out.println("ThreadLocal的值为："+booleanThreadLocal.get());
}
}).start();
//子线程2
new Thread(new Runnable() {
@Override
public void run() {
booleanThreadLocal.set(3);//设置子线程2的值为3
System.out.println("ThreadLocal的值为："+booleanThreadLocal.get());
}
}).start();
//子线程3
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("ThreadLocal的值为："+booleanThreadLocal.get());
}
}).start();
打印结果如下：
可以看到每个线程打印的都是我们设置的值，因为在子线程3我们没有设置值，所以打印的是null。
ThreadLocal之所以能实现上述的效果，是因为不同线程访问同一个ThreadLocal的get方法，ThreadLocal内部会从各自线程中取出一个数组，然后根据当前ThreadLocal的索引去查找对应的value。显然每个线程的数组是不同的，所以通过ThreadLocal可以在指定线程存储数据，其他线程无法访问，不同线程间彼此互不干扰。
想弄清ThreadLocal的实现原理，需要弄清它的set方法和get方法
这里先介绍一下set方法执行的大概流程，再来介绍一下源码：
1.首先我们会获取当前的线程，然后根据当前的线程获取当前线程的ThreadLocalMap对象（ThreadLocalMap使用一个数组作为存储结构，数组元素为Entry，传入的的ThreadLocal对象作为Entry的key，要存入的值为value）
2.如果获取到了当前线程的ThreadLocalMap对象，那么就将数据存进去
3.如果获取的ThreadLocalMap对象是null，那么就为当前线程创建一个ThreadLocalMap对象
源码分析
打开ThreadLocal的原码找到set方法：
public void set(T value) {
Thread t = Thread.currentThread();//获取当前线程
ThreadLocalMap map = getMap(t);//获取当前线程对应的ThreadLocalMap对象
if (map != null) {
map.set(this, value);//这里的this就是当前线程的ThreadLocal对象
} else {
createMap(t, value);
}
}
这个set方法接受一个value参数，这个参数可以指定为任何类型，我们先获取当前线程接着获取当前线程的ThreadLocalMap对象，如果当前线程有ThreadLocalMap对象，那么就将数据直接存进去（存进一个Entry对象，当前线程的ThreadLocal对象作为key，要存储的数据作为value）；如果当前线程没有ThreadLocalMap对象，那么我们就需要去创建一个ThreadLocalMap对象：
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
private static final int INITIAL_CAPACITY = 16;
private Entry[] table;
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//初始化一个数组
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);//计算key的存储位置
table[i] = new Entry(firstKey, firstValue);//将数据放到计算出的位置
size = 1;
setThreshold(INITIAL_CAPACITY);
}
可以看到当调用createMap方法后回去创建一个ThreadLocalMap实例，在创建ThreadLocalMap实例时，会初始化一个数组，这个数组就是我们真正用于存取数据的数据结构，这个数组存储数据的数据类型是Entry，也就是一个key-value的数据结构。接着我们会通过传给我们的ThreadLocal参数计算出这个key的储存位置并将数据存到计算出的位置。
小结一下这个过程：我们的每个Thread（线程）都有唯一的一个ThreadLocalMap对象，这个ThreadLocalMap对象使用Enrty[]数组存储数据，Entry[]数组的每个元素都是以当前线程的ThreadLocal对象作为key，要存储的数据作为value的数据结构。
另外提一下使用数组是因为同一线程中可能有多个不同类型的ThreadLocal对象，它们计算出的key是不同的，就对应了在数组上不同的存储位置。
源码分析
找到get方法
public T get() {
Thread t = Thread.currentThread();//获取当前线程
ThreadLocalMap map = getMap(t);//获取当前线程对应的ThreadLocalMap对象
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();//表示当前线程都没有ThreadLocalMap对象或者有ThreadLocalMap对象当不存在ThreadLocal关联的Entry对象，去做一些初始化的工作
}
同样先获取当前线程再获取当前线程的ThreadLocalMap对象，如果对象不为空，那么就根据key也就是ThreadLocal对象去获取Entry对象，最后获取到的Entry对象不为空时将数据返回，获取Entry对象的方法如下：
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);//计算出存储的位置
Entry e = table[i];
if (e != null && e.refersTo(key))
return e;
else
return getEntryAfterMiss(key, i, e);
}
根据传入的key计算出key的存储位置，这个过程在我们set()方法存储数据时是相对应的，都是根据key（ThreadLocal对象）计算出在数组上的存储位置，接着直接存储位置直接获得Entry对象返回。
通过ThreadLocal的get方法和set方法可以看出，不同线程操作的都是各自线程中的ThreadLocalMap对象的Entry[]数组，所以ThreadLocal可以实现线程间存取数据互不干扰。
MessageQueue也就是消息队列，虽然它叫做消息队列，但它的实现方法并不是队列，而是使用一个单链表来实现消息列表。
MessageQueue主要有两个方法：enqueueMessage()插入消息和next()读取消息，需要注意的是读取消息时会伴随着消息的删除操作，也就是在读取完这条消息后将其从消息队列中移除。
Looper在Android消息机制中扮演循环者的角色，它会不停在MessageQueue中查看是否有新消息，如果有新消息就立即处理，否则就一直阻塞在那。在创建Looper时会创建一个MessageQueue对象并获取当前的线程，源码如下：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
上面我们介绍过，Handler的工作需要Looper，如果一个线程没有Looper对象使用Handler对象就会报错，那么我们怎么获取Looper对象呢，答案是直接调用Looper.prepear()方法即可创建一个Looper对象，然后通过Looper.loop()来开启消息循环，如下：
//子线程1
new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
Handler hanlder=new Handler();
Looper.loop();
}
}).start();
Looper也是可以退出的，有quit()和quitSafely()两种方法，使用quit()会直接退出Looper，而quitSafely()会设置一个退出标记，接着把消息队列中已有的消息处理完毕才能安全退出。当Looper退出后，使用Handler的send方法发消息会返回false。
如果我们在子线程中创建了Looper，那么我们就应该在所有事做完之后调用上述两个方法退出Looper。
上面我们还提到了一个loop()方法，只有调用Looper.loop()方法后，消息循环系统才会真正的起作用，我们可以看看它的源码：
打开loop()方法的源码我们可以看到有下面一段代码：
for (;;) {
if (!loopOnce(me, ident, thresholdOverride)) {
return;
}
}
首先我们可以知道loop方法是一个死循环，只有当!loopOnce(me, ident, thresholdOverride条件满足时才会跳出循环，接着我们打开loopOnce方法看看，首先里面有段代码：
Message msg = me.mQueue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return false;
}
loop()方法会调用MessageQueue的next()方法一直获取消息，此时一直会处于循环状态。只有当MessageQueue的next()方法返回了null循环才会结束，那么什么情况下MessageQueue的next()方法才会返回null呢。答案是当Looper调用了quit()方法或quitSafely()方法时，我们看看这两个方法：
public void quit() {
mQueue.quit(false);
}
public void quitSafely() {
mQueue.quit(true);
}
可以看到Looper的quit()方法和quitSefely()方法这两个方法调用了MessageQueue的quit()方法，我们打开MessageQueue来看看它的quit()方法：
void quit(boolean safe) {
if (!mQuitAllowed) {
throw new IllegalStateException("Main thread not allowed to quit.");
}
synchronized (this) {
if (mQuitting) {
return;
}
mQuitting = true;
if (safe) {
removeAllFutureMessagesLocked();
} else {
removeAllMessagesLocked();
}
// We can assume mPtr != 0 because mQuitting was previously false.
nativeWake(mPtr);
}
}
MessageQueue的quit()方法接收一个布尔型参数用来表示是不是安全的，也就是区分Looper的quit()方法和quitSafely()方法。MessageQueue的quit()方法中有段代码，用来真正进行处理：
if (safe) {//quitSafely()安全退出
removeAllFutureMessagesLocked();
} else {//quit()
removeAllMessagesLocked();
}
点进这两个方法你会发现，这两个方法都是将MessageQueue.next()方法返回的值设为null，这样我们的Looper.quit()和Looper.quitSafely()方法就会执行，Looper退出。
如果MessageQueue的next()方法返回的值不为null，那么就会调用loopOnce()方法里的msg.target.dispatchMessage(msg);方法来处理这条消息，msg.target表示发送这条消息的Handler对象，也就是说Handler发送完消息，这条消息最终又交给Handler的dispatchMessage()方法来处理了，但dispatchMessage()方法是在Looper.loop()方法中执行的。这样我们就可以实现在子线程执行耗时操作，然后在子线程调用Looper.loop()方法执行Handler的dispatchMessage()方法，通知Handler来处理消息，最后到主线程（也就是Handler所在的线程）进行处理消息的操作了。
Handler主要包括消息的发送和接收。发送就是通过post的一系列方法以及send的一系列方法来完成的，其实post的一系列方法最终也是通过send的一系列方法来实现的。
Handler的sendMessage()方法经过层层调用最终会调用到一个enqueueMessage()方法，是不是有点眼熟，在MessageQueue中我们就是通过这个方法插入消息，在Handler的enqueueMessage()方法就是调用MessageQueue.enqueueMessage()方法来向消息队列中添加一条消息，Handler的enqueueMessage()方法如下：
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
long uptimeMillis) {
msg.target = this;
msg.workSourceUid = ThreadLocalWorkSource.getUid();
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);//调用MessageQueue的enqueueMessage()方法插入一条消息
}
当调用Handler的send()方法时，MessageQueue的enqueueMessage()方法执行向消息队列中插入一条消息，同时MessageQueue的next()方法执行将这条消息返回给Looper（Looper通过loop()方法一直在MessageQueue中获取消息），Looper接收到消息就开始处理，最终消息交给Handler处理，即Handler.dispatchMessage()方法被调用，此时Handler进入处理消息阶段，我们可以打开Handler的源码看看dispatchMessage()方法：
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
这个方法中首先检查Message的callback对象（一个Runnable对象，就是Handler的post()方法传递的Runnable参数），不为空使用handleCallback(msg)方法处理消息。如果没有传递Runnable参数，也就是msg.callback为空，那么就接着判断mCallback是否为空，Callback是一个空接口，其源码定义如下：
public interface Callback {
/**
* @param msg A {@link android.os.Message Message} object
* @return True if no further handling is desired
*/
boolean handleMessage(@NonNull Message msg);
}
通常我们在开发过程中，创建Handler的方式是派生一个Handler的子类并重写其handlerMessage()方法来进行具体的消息处理。当我们不想派生子类时，就可以通过Callback这样创建一个Handler对象Handler handler=new Handler(callback)，这样我们就不需要派生Handler的子类。
其实上面代码不是特别重要，重要的是handleMessage(msg)这个方法。Handler的dispatchMessage()方法最终，调用handleMessage()方法来进行具体的消息处理。
最后我们总结一下上面讲到的几个方法的相互之间的调用：
最终我们就可以实现在子线程执行耗时操作，再在子线程通过dispatchMessage()方法通知主线程执行handleMessage()方法，在主线程更新UI。
分享到此结束，共勉！