简介
在Android日常开发中，Handler的使用是非常高频的。其类似于一种通信机制，这种机制主要靠Handler、Looper和MessageQueue的协同合作。
MessageQueue：消息队列，先进先出，在获取下一条消息的时候可能因为没有消息从而阻塞。
Looper：通过ThreadLocal修饰，保证每一个线程都有一个独立的Looper。工作开始后会处于一个无限循环，不停地从MessageQueue取出消息，然后传递给Message指定的Handler处理。
Handler：投递消息和处理消息，将生成一个新的消息Message，然后交给对应Looper中的Message，等待Looper取出的消息进行回调处理。
Looper
//用于管理不同线程下不同的Looper
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
//UI线程的Looper，一般在整个进程开始的时候就创建了，后续可以直接使用
private static Looper sMainLooper;
//当前Looper持有的消息队列
final MessageQueue mQueue;
//当前Looper关联的线程
final Thread mThread;
Looper通过ThreadLocal保证在每一个线程中都有唯一且确认的Looper，内部持有一个唯一的消息队列和创建线程。
/**
* 准备Looper
*/
public static void prepare() {
prepare(true);//默认允许消息队列退出
}
/**
* 准备Looper
* @param quitAllowed true允许MessageQueue通过quit退出，false当quit的时候会抛出异常
*/
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {//当前线程已经绑定有Looper
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
/**
* 创建一个新的Looper
* @param quitAllowed
*/
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);//新建一个消息队列
mThread = Thread.currentThread();//绑定当前线程
}
Looper不存在显示的构造方法，通过静态方法prepare可以在当前线程中构建Looper，但是不允许重复prepare，一个线程中只允许准备一个Looper
/**
* 通过当前调用线程获得对应的Looper
*/
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
/**
* Looper开始工作
*/
public static void loop() {
final Looper me = myLooper();//获得当前调用线程的Looper
if (me == null) {//必须先创建Looper
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;//获得Looper对应的消息队列
//...
for (;;) {//无限循环
Message msg = queue.next(); //当队列中没有数据或者下一条消息需要延时的时候可能会阻塞，next()内部本身就是一个死循环
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
//...
//成功取出下一条Message
try {
//将消息回调到Handler中处理
msg.target.dispatchMessage(msg);
} finally {
//...
}
//...
msg.recycleUnchecked();//当前消息分发处理完成，回收当前消息，用于后期复用
}
}
当一个新的线程准备好了Looper之后，要让Looper开始工作需要loop()，在一个无限循环中不停地从Looper中的消息队列中取出消息并且回调到对应的Handler中处理，在这个过程中如果取不出消息则会阻塞，有消息可以获得的时候会唤起。
Handler
/**
* 默认构造函数，会自动关联当前调用线程的Looper
* 如果当前线程没有创建Looper，会抛出异常
*/
public Handler() {
this(null, false);
}
/**
* 会自动关联当前调用线程的Looper，并且指定消息的回调处理
* 如果当前线程没有创建Looper，会抛出异常
*
* @param callback 用于处理消息的回调，可以为null
*/
public Handler(Handler.Callback callback) {
this(callback, false);
}
/**
* 使用特定的Looper，并且指定消息的回调处理
*
* @param looper 必须为非空的Looper
* @param callback 用于处理消息的回调，可以为null
*/
public Handler(Looper looper, Handler.Callback callback) {
this(looper, callback, false);
}
/**
* 使用特定的Looper
*
* @param looper 必须为非空的Looper
*/
public Handler(Looper looper) {
this(looper, null, false);
}
/**
* 会自动关联当前调用线程的Looper，并且指定消息的回调处理
* 如果当前线程没有创建Looper，会抛出异常
*
* @param callback 用于处理消息的回调，可以为null
* @param async 在将消息推入消息队列之前，会通过Message的setAsynchronous设置Message的属性
*
* @hide
*/
public Handler(Handler.Callback callback, boolean async) {
mLooper = Looper.myLooper();//关联当前调用线程的Looper
if (mLooper == null) {//要求当前线程必须初始化一个Looper
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;//绑定Looper的消息队列
mCallback = callback;
mAsynchronous = async;
}
/**
* 使用特定的Looper，并且指定消息的回调处理
*
*
* @param looper 必须为非空的Looper
* @param callback 用于处理消息的回调，可以为null
* @param async 在将消息推入消息队列之前，会通过Message的setAsynchronous设置Message的属性，后续通过这个Handler发送的消息都是异步消息，如果消息队列设置了同步屏障，那么只会执行这些消息，否则就和普通消息没有什么区别
*
* @hide
*/
public Handler(Looper looper, Handler.Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
这里有消息的异步属性，不过后面会看到正常使用的时候并没有什么作用。
重点是可以看到Handler在构建的时候必须关联指定的Looper，同时会绑定Looper里面对应的MessageQueue，这样关联关系就构建完成。
/**
* 发送一条延时处理的消息，并且指定回调
* @param r 当前消息的回调处理
* @param delayMillis 消息的处理延时
* @return 当前消息是否发送成功
*/
public final boolean postDelayed(Runnable r, long delayMillis)
{
//生成一个有指定回调的消息，并且在指定延时后发送消息
return sendMessageDelayed(getPostMessage(r), delayMillis);
}
/**
* 获得一条消息，并且指定回调
* @param r 当前消息的回调处理
* @return Message
*/
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();//尝试复用一个Message
m.callback = r;//指定callback为对应的Runnable
return m;
}
/**
* 发送一条延时处理的消息，并且指定回调
* @param msg 需要发送的消息
* @param delayMillis 消息的处理延时
* @return 当前消息是否发送成功
*/
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {//处理延时必须大于等于0
delayMillis = 0;
}
//发送一条在当前时间+延时时间的时间点处理的消息
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
/**
* 将消息放入指定消息队列当中
* @param msg 需要放入到消息队列的消息
* @param uptimeMillis 消息需要被回调的时间
* @return true表示消息放入到消息队列成功，false失败
*/
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;//获得当前Looper关联的消息队列
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
//将消息放入当前Looper关联的消息队列
return enqueueMessage(queue, msg, uptimeMillis);
}
/**
* 将消息放入指定消息队列当中
* @param queue 需要放入的消息队列
* @param msg 需要放入到消息队列中的消息
* @param uptimeMillis 当前消息回调的时间
* @return true表示消息放入到消息队列成功，false失败
*/
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;//指定当前消息的target为当前发送的Handler
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);//调用消息队列的方法将消息放入队列当中
}
可以看到，Handler发送消息实际上就是把Message放入到对应Looper的MessageQueue中，然后工作中的Looper会在指定的时间取出当前Message，然后再次回调到Handler当中。
/**
* 在Looper的loop执行的线程中进行的回调
* 用于处理消息
* @param msg 需要处理的消息
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {//如果消息是直接通过post(Runnable)的类似方式发送到队列中的
handleCallback(msg);
} else {
if (mCallback != null) {//Handler在创建的时候如果指定了Callback，优先回调到Callback中
if (mCallback.handleMessage(msg)) {//Callback处理消息完成是否结束本次回调
return;
}
}
//如果是直接通过sendMessage之类的方式发送到队列中，并且在构建Handler的时候没有指定Callback的时候
//回调Handler中的方法
handleMessage(msg);
}
}
/**
* 回调消息在发送之前设置的Runnable
* @param message 当前需要处理的消息
*/
private static void handleCallback(Message message) {
message.callback.run();
}
/**
* 对于普通的sendMessage...之类的消息
* 可以通过直接复写该方法从而进行统一的消息处理
* @param msg 需要处理的消息
*/
public void handleMessage(Message msg) {
}
当Looper成功获得对应Handler的消息的时候，会将消息在Looper所在的线程中交由Handler处理。优先级如下：
1.Message有指定Runnable，回调Runnable，消息处理结束，否则2
2.Handler在构建的时候指定Callback，回调Callback，如果Callback返回true，消息处理结束，否则继续3
3.否则回调Handler中的handlerMessage方法，这个一般在开发中用的会多一些
除此之外可以看到，如果想要Handler的处理方法运行在非UI线程上，只需要指定非UI线程的Looper即可，比方说官方提供的HandlerThread和Handler组合的模式。
HandlerThread handlerThread = new HandlerThread("msg_handler");
handlerThread.start();
Handler.Callback callback = new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
//在HandlerThread的线程中做些什么。。。
//在handleMessage之前处理
return false;
}
};
Handler handler = new Handler(handlerThread.getLooper(), callback){
@Override
public void handleMessage(Message msg) {
//在Callback执行完毕之后，在HandlerThread的线程中继续做些什么。。。
}
};
handler.sendEmptyMessage(0);
通过上面的这种方法就可以让Handler在子线程中处理消息的回调。
Message
//复用池队列数据变化锁，类似读写锁
private static final Object sPoolSync = new Object();
//当前复用池队列的头指针，或者说队首消息
private static Message sPool;
//当前消息在消息链表中的下一条消息
Message next;
//当前复用池的大小
private static int sPoolSize = 0;
//复用池队列的最大长度，超过不再接受旧的消息
private static final int MAX_POOL_SIZE = 50;
/**
* 从复用池队列中尝试复用已有的Message
* 如果没有则新建
* @return 可用的Message
*/
public static Message obtain() {
synchronized (sPoolSync) {//复用池队列数据变化锁
if (sPool != null) {
Message m = sPool;//获得队首元素
//将队首元素移出队列
sPool = m.next;//当前队列头指针指向第二个元素
m.next = null;//断开队首元素指向第二个元素的指针，从而从队列中移出完成
m.flags = 0; // clear in-use flag
sPoolSize--;//复用池队列数量-1
return m;//复用当前复用池队首的消息
}
}
//如果复用池没有可以复用的消息，新建消息
return new Message();
}
/**
* 回收当前消息并且放在复用池链表的头部
* 用于后期的复用
*/
void recycleUnchecked() {
//... 首先清空数据
synchronized (sPoolSync) {//复用池队列数据变化锁
if (sPoolSize < MAX_POOL_SIZE) {//当前复用池中的数据还没到设置的最大值
//将当前消息插入到复用池的头部
next = sPool;//当前消息指向复用池队列的头指针
sPool = this;//当前消息作为复用池队列的头指针，插入完成
sPoolSize++;//当前复用池中的消息数量+1
}
}
}
消息采用复用机制，通过一个后进先出的队列来进行管理，队列默认最大大小为50个Message。
在Android中Handler使用还是比较频繁，通过Message的复用还是可以减少频繁的内存分配和回收。
Message在Looper中回调到Handler处理完成之后会自动回收，所以平时在使用的过程中不应该手动进行回收。
MessageQueue
/**
* 将消息放入消息队列当中
* 消息队列会按照消息的执行时刻进行排列，执行时刻早的位于队列的前面
* @param msg 需要放入的消息
* @param when 当前消息设置的执行时刻
* @return true表示放入消息队列成功，false在MessageQueue已经quit的情况下会返回，表示当前MessageQueue不可用
*/
boolean enqueueMessage(Message msg, long when) {
//...一些检查
synchronized (this) {
if (mQuitting) {
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w(TAG, e.getMessage(), e);
msg.recycle();
return false;
}
msg.markInUse();
msg.when = when;//标记当前消息的执行时刻
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
//1.当前消息队列为空
//2.当前消息需要立刻执行
//3.当前消息执行时刻比队首消息还要早
//以上三种情况需要将当前消息插入到消息队列的头部即队首
msg.next = p;
mMessages = msg;
needWake = mBlocked;//如果之前next处于阻塞状态，需要尝试唤起队列
} else {//在非队列头部的地方插入消息
//如果之前next处于阻塞状态，并且当前消息为异步消息，需要尝试唤起队列
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
for (;;) {//遍历整个消息队列
prev = p;
p = p.next;
//到达队列尾部或者后一条消息的运行时刻大于当前消息
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
//将当前消息插入到消息队列当中
msg.next = p;
prev.next = msg;
}
if (needWake) {//如果需要唤醒队列，会尝试唤起队列，则next()会继续执行
nativeWake(mPtr);
}
}
return true;
}
/**
* 从消息队列中获取下一条用于回调的消息
* @return 用于回调的消息
*/
Message next() {
final long ptr = mPtr;
if (ptr == 0) {//当前消息队列已退出
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {//开始
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);//阻塞指定的时间，nextPollTimeoutMillis指定下一次唤醒时间间隔
synchronized (this) {
final long now = SystemClock.uptimeMillis();//当前时刻
Message prevMsg = null;
Message msg = mMessages;//标记消息队列队首消息
//当target为null的时候，这种场景只能通过postSyncBarrier实现
if (msg != null && msg.target == null) {
//当通过postSyncBarrier放入的消息之后
//只会执行指定了Asynchronous属性的Handler发送的消息或者手动设置为Asynchronous的消息
//这种消息也就是相当于一个同步屏障的作用，导致MessageQueue只会取出异步消息
//从而导致Handler不会执行同步的消息，而只会执行异步的消息
//默认情况下这种消息不会自动移除，除非调用removeSyncBarrier
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {//当前消息队列不为空
if (now < msg.when) {//当前还没有到最快执行的消息的执行时刻
//延时指定的时间
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {//当前消息可以执行
mBlocked = false;
if (prevMsg != null) {//当前消息为异步消息，此时可能是队列中间的某一个消息
prevMsg.next = msg.next;//将当前消息前面的链表和后面的链表连在一起
} else {
mMessages = msg.next;//链表头指针变成队列中第二个消息
}
msg.next = null;//断开当前消息在队列中的指针，从而成功将当前消息从链表中移出
msg.markInUse();//标记的当前消息在使用中
return msg;//返回队首消息
}
} else {
//消息队列没有满足要求的消息或者消息队列为空
nextPollTimeoutMillis = -1;
}
if (mQuitting) {
dispose();
return null;
}
//执行到这里，说明当前消息队列没有可以执行的消息，可能没有到执行时间或者队列中就没有消息
//接着尝试进行当前消息队列空闲的监听回调，可以手动通过addIdleHandler添加监听回调
//空闲回调在一次next的过程中只能回调一次
//如果当前队列为空或者还没有到下一条消息的执行时刻，即处于空闲状态
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
//标记回调的数量，从而也意味着当前准备开始回调
//后续pendingIdleHandlerCount都不会小于0，也就不会再次回调
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {//当前没有设置监听回调
mBlocked = true;//标记需要阻塞，因为当前队列空闲
continue;//继续循环，从而进入到nativePollOnce进行阻塞
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new MessageQueue.IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
// 尝试进行空闲回调
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final MessageQueue.IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {//如果空闲回调处理返回false，这里会自动移除回调
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
// 标记需要进行空闲回调的数量为0，这样后续循环不会再次进行空闲回调
pendingIdleHandlerCount = 0;
//如果进行了空闲回调，那么也许会有新消息的到来，则下一次进入循环先不阻塞
nextPollTimeoutMillis = 0;
}
}
MessageQueue中维持着一个按照消息执行时刻排序的列表，插入消息的时候会按照时刻所处位置进行插入。
Looper在loop()中不停地循环MessageQueue的next()方法，next()方法会尝试将第一条可用消息提供。
可以看到异步的消息会优先执行，通常使用下的消息都会有对应的target，除非通过MessageQueue的postSyncBarrier()设置一个同步屏障，这样会导致后续只执行异步的消息。
空闲回调
1.如果消息队列为空，首先会尝试回调空闲Handler，然后再次尝试获取新消息，如果还没有新消息，则会一直阻塞，等待enqueMessage中插入消息的唤起。
2.如果消息队列不为空，但是第一条消息还没有到指定的执行时刻，首先会尝试回调空闲Handler，然后再次尝试获取新消息，如果还没有新消息，则会阻塞到第一条消息执行的时刻。
3.每一次next()只能获得一条消息，并且对应的空闲回调只有一次。（使用例子可以看Glide对于activeResource弱内存缓存的回收处理）
总结
如果把这个工作比作是一个工厂出品一个零器件。
Handler就是工厂大门两端的加工人员，在大门入口负责把新来的零件放到循环工作的履带，然后在大门出口负责最后把零件包装一下然后送出去。
MessageQueue就是这个履带，零件在履带上面按照它们的执行循序排列。
Looper就是履带上面的自动机器手，在特定的时刻将履带上面对应的零件交给出口的Handler。
