概述
Handler通常被我们开发者用来从子线程中发送消息通知主线程跟新UI，但是这只是Handle的冰山一角，本文从源码的角度彻底解析Handler消息机制的原理。
Handler机制只要涉及的几个类：
主要从以下方面来分析整个源码：
- Handler、Looper、MessageQueue、Message的源码
- mainThread 的 handler 和 looper（从ActivityThread.main开始）
- 整个消息发送的流程
- 分析每个环节的代码细节
- Handler、Looper和Thread之间的关系
- 由handler造成的内存泄露问题
整个消息发送、接收流程的大致梳理
第一步：handle.sendMessage()把消息发送给对应线程的Looper的消息列队（每个looper持有一个MessageQueue）
第二步：Looer.loop()不断轮询取出消息
第三步：取出消息后发送给对应的Handler
系统主线程中的Handler
Handler在Android的整个架构中间不仅仅只是负责更新UI的作用，通过分析AcitivityThread的源码可以看到，系统一开始帮我们初始化一个主线程的Handler和Looper,Activity、Service等的生命周期的消息都是经过Handler来处理的，可见Handler的重要性。我们都知道Java的程序入口是main函数，Android自然也是一样
AcitivityThread#main
final H mH = new H();
public static void main(String[] args) {
...
//在main线程里初始化一个Looper
Looper.prepareMainLooper();
//开启死循环，不断轮询MessageQueue一旦有消息，从列队中取出发送
Looper.loop();
...
}
private class H extends Handler {
}
首先调用Looper.prepareMainLooper()，初始化一个Looper将Looper和main线程绑定,然后在AcitivityThread里面懒加载了一个H变量，H继承的Handler，最后Looper.loop()开启死循环，不断轮询MessageQueue一旦有消息，从列队中取出发送。
接下来看看H.handleMessage()干了哪些事情，抽取几个分析：
public void handleMessage(Message msg) {
...
case BIND_SERVICE://绑定服务
...
case PAUSE_ACTIVITY://Activity的生命周期控制
...
case EXIT_APPLICATION://退出应用
Looper.myLooper().quit();
break;
}
可以看到Android系统的消息机制、事件反馈机制等的消息都是由Handler来进行分发的。
看到这里可能大家会有这么一个疑问，那就是看到AcitivityThread.main方法里面就寥寥几行代码，main方法运行完了整个App程序不也就退出了吗？为什么App能够一直存在呢？因为Looper.loop()里面执行了一个死循环。循环退出了，main函数执行完了，程序也就退出了，这就是上面Looper.myLooper().quit()退出looper的死循环就退出应用的原因。
到这里，我们看到要通过Handler向一个线程发送消息要有这几个步骤：
- 初始化一个Looper和线程绑定起来，一个线程最多只能有一个Looper（具体原因后面分析）
- 初始化一个Handler，用来发送消息给Looper的MessageQueue
- Looper.loop()开启死循环，不断轮询MessageQueue取出消息发送
我们平时常在主线程中new的Handler不用经历这些步骤，那是应为在app启动的时候系统帮我们已经做好了。
到这里，有几个疑问就是：
Handler是怎么和Looper绑定的呢?明明new Handle的时候和Looper半毛钱关系都没有
多个Handler怎么可以同时向一个Looper的MessageQueue发送消息呢？（ActicityThread中的H和我们平时用的handler就是）
Looper
前面提到的，Handler的使用第一步就是Looper.prepare()，初始化Looper与线程绑定。
public class Looper {
//全局的sThreadLocal
private static final ThreadLocal sThreadLocal = new ThreadLocal();
// Looper内的消息队列
final MessageQueue mQueue;
// 当前线程
Thread mThread;
// 。。。其他属性
// 每个Looper对象中有它的消息队列，和它所属的线程
private Looper() {
mQueue = new MessageQueue();
mRun = true;
mThread = Thread.currentThread();
}
// 我们调用该方法会在调用线程的TLS中创建Looper对象
public static final void prepare() {
//从当前线程拿Looper
if (sThreadLocal.get() != null) {
//如果线程中已经初始化了Looper，则抛出异常，这就是为什么一个线程只能有Looper
throw new RuntimeException("Only one Looper may be created per thread");
}
//new 一个Looper存放到线程
sThreadLocal.set(new Looper());
}
// 其他方法
}
prepare()首先调用sThreadLocal.get()，会去检测当前线程中是否已经初始化了Looper，如果已经有Looper，则抛异常，这里就规定了一个线程只能有一个Looper。如果多次调用Looper.prepare的话就会抛异常。然后调用sThreadLocal.set(new Looper()),将Looper保存到对应的Thread中。发现没有Looper的构造是private的，所有的Looper实列化都必须通过prepare()，Looper构造里面初始化了MessageQueue对象，所以每个Looper拥有一个消息队列。
Looper和Thread能够绑定的关键在于sThreadLocal.set()，ThreadLocal是用于线程安全的，具体的不做讨论。sThreadLocal是一个静态变量，系统初始化的时候就存在的。进一步看sThreadLocal.set()的源码
public void set(T value) {
//获取当前线程
Thread currentThread = Thread.currentThread();
//拿到Thread中的localValues变量
Values values = values(currentThread);
if (values == null) {
values = initializeValues(currentThread);
}
//将全局的ThreadLocal（Looper.sThreadLocal）作为键，Looper作为值存到线程的ThreadLocal.Values localValues变量中
values.put(this, value);
}
Values values(Thread current) {
return current.localValues;
}
class Thread{
ThreadLocal.Values localValues;
}
首先拿到当前线程，获取Thread的一个变量localValues，Values 是ThreadLocal的一个内部类，以键值对存放数据，是一个散列链表，和HashMap类似。Looper就是这样和Thread绑定的。
looper()方法：
public static final void loop() {
Looper me = myLooper(); //得到当前线程Looper
MessageQueue queue = me.mQueue; //得到当前looper的MQ
// 开始循环
for (;;) {
Message msg = queue.next(); // 取出message
if (msg != null) {
if (msg.target == null) {
// message没有target为结束信号，退出循环
return;
}
// 非常重要！将真正的处理工作交给message的target，即后面要讲的handler
msg.target.dispatchMessage(msg);
...
msg.recycleUnchecked();
}
}
}
myLooper()方法主要是通过sThreadLocal去拿到当前线程的Looper对象
然后拿到消息队列mQueue
public static Looper myLooper() {
return sThreadLocal.get();
}
再通过queue.next()从消息队列中取出消息msg，然后msg.target.dispatchMessage(msg);把消息发送给handler，msg.target就是handler的引用，是在Handler.sendMessage的时候赋值的，调用handler.dispatchMessage()方法最后会调用我们熟悉的handler.handlerMessage()方法，来让我们处理消息。
最后一步msg.recycleUnchecked()把消息回收放入消息池内。
小结：
Looper.prepare()方法初始化一个Looper对象同时为Looper实例化了一个MessageQueue，并且通过全局变量sThreadLocal将初始化Looper的线程和Looper对象关联，将Looper对象存储在当前Thread变量中。
Looper.loop()方法正式将Looper运行起来，不断循环从消息队列取消、发送消息、回收消息。
Handler
Handler使用的时候分两步：
new Handler 、handler.sendMessage()或者handler.post()，这时候Looper影子都没见着，Handler是怎么把消息发送到线程的Looper.mQueue中去的呢？答案就在Handler的构造中：
public Handler(Callback callback, boolean async) {
...
//拿到当前线程的Looper
mLooper = Looper.myLooper();
//这里表示在初始化Handler之前，必须初始化Looper，不然抛异常
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;
}
首先在构造里面会去拿到与当前线程（也就是初始化Handler的线程）的Looper、MessageQueue，赋值给Handler的成员变量，这里就解释了Handler怎么和Looper怎么关联起来的了而且多个handler可以同时向同一个Looper的消息列队发送消息，因为他们拿到的是同一个Looper，中间的纽带就是Thread。
在来看sendMessage()，通过几个重载的方法最终调用下面函数：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
//直接把关联looper的MessageQueue 作为自己的MessageQueue ，因此它的消息将发送到关联looper的MessageQueue 上
return queue.enqueueMessage(msg, uptimeMillis);
}
可以看到msg.target = this将当前的Handler赋值给了Message的变量，这就是为什么Looper在取出Message的时候能够准确的发送给相应的Handler。最终把消息放入消息队列。uptimeMillis是延时发送的时间，最终在queue.enqueueMessage(msg, uptimeMillis)会存入msg中。
在Handler中的另外几个点：
1、handler.post(runnable)
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
最终同样也是调用sendMessageAtTime(),以前老以为这里Runable是和线程有关，看源码才知道和线程半毛钱关系都没有，仅仅只是一个接口，在看getPostMessage(r)：
private static Message getPostMessage(Runnable r, Object token) {
//得到一个消息实例
Message m = Message.obtain();
m.obj = token;
//把Runable对象赋值给了Message的一个变量最终返回msg
m.callback = r;
return m;
}
Runnable 对象赋值给了Message的一个变量，最终还是把返回的Msg，之后流程和handler.sendMessage()一样的了.
在Looper.loop()中msg.target.dispatchMessage(msg)来发送消息最终调用的是Handler.dispatchMessage()方法，
public void dispatchMessage(Message msg) {
//如果是handler.post(Runable)走这里
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {//自定义回调
if (mCallback.handleMessage(msg)) {
return;
}
}
//常规的回调
handleMessage(msg);
}
}
首先会去检查msg是否有callback 也就是上面讲的Runable对象，如果有则是我们常用的handler.post()这种调用方式，接下来回去判断mCallback 是否为空，这个mCallback 是Handler的内部类，在Handler的重载的构造中赋值，如果是自定义的回调则调用mCallback.handleMessage()，这样就不会回调handler.handlerMessage(),最后调用handler.handlerMessage();
到此消息发送、接收的原理和流程就分析完了。这里还有个经典的案列：向子线程中发送消息。
其实Looper的源码注释已经写得很明白了，也给出了示例代码：
public Handler mHandler;
class LooperThread extends Thread {
* public void run() {
* Looper.prepare();
*
* mHandler = new Handler() {
* public void handleMessage(Message msg) {
* // process incoming messages here
* }
* };
*
* Looper.loop();
}
mHandler.sendMessage（）；
首先：初始化子线程的Looper，关联Looper和子线程
其次：初始化Hander，拿到当前线程的Looper赋值给Handler最为成员变量
最后：Looper.loope()死循环，不断从消息列队取消息
最终handler.handlerMessage()在Looper.loop()中被调用，所以handlerMessage()运行在子线程中。
未完
