在上一篇文章中，我们分析了Handler基本流程，下面分析一些上层开发很少接触的部分。
IdleHandler
从命名可以看出IdleHandler 是Handler出现空闲时的一种机制，IdleHandler是一种只有当消息队列没有消息时或者当前队列中的消息还没有到执行时间时才会执行idleHandler.
IdleHandler 是MessageQueue的静态内部类：
public static interface IdleHandler {
/**
*当MessageQueue中消息为空时
*或者当前消息队列中没有需要处理的消息时，会调用该方法
*return true queueIdle 会重复执行 false 执行一次
**/
boolean queueIdle();
}
可以看到IdleHandler是一个回调接口，外部通过addIdleHandler将实现类添加到MessageQueue中
private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();
public void addIdleHandler(@NonNull IdleHandler handler) {
if (handler == null) {
throw new NullPointerException("Can't add a null IdleHandler");
}
//线程安全，可以在任何线程中添加
synchronized (this) {
mIdleHandlers.add(handler);
}
}
mIdleHandlers 是一个存放IdleHandler的List。IdleHandler是在MessageQueue 空闲时被调用，那么很明显是在出队列方法next中执行。
private android.os.MessageQueue.IdleHandler[] mPendingIdleHandlers;
android.os.Message next() {
int pendingIdleHandlerCount = -1; // -1 only during first iteration
for (;;) {
synchronized (this) {
//省略部分代码
/**
* 1.pendingIdleHandlerCount < 0
* 2. mMessages == null 队列中消息为空
* 3. now < mMessages.when 下一个待执行的消息执行时间比当前晚
*/
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
// No idle handlers to run. Loop and wait some more.
mBlocked = true;
continue;
}
//转换为数组
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
//真正调用的地方
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
//获取queueIdle返回值
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
//queueIdle返回值 为false时，从List中删除
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
// Reset the idle handler count to 0 so we do not run them again.
pendingIdleHandlerCount = 0;
}
}
消息队列的退出
在消息队列中MessageQueue有一个mQuitting字段，在next方法中会使用到这个字段，这个字段用来判断是否当前MessageQueue是否退出。
我们无法直接通过MessageQueue进行
public void quit() {
mQueue.quit(false);
}
public void quitSafely() {
mQueue.quit(true);
}
这两个方法内部都会调用MessageQueue的quit(boolean safe)方法。
void quit(boolean safe) {
//判断是否允许Message quit
//我们调用Looper.prepare()初始化Looper时mQuitAllowed是true
//主线程调用repareMainLooper() mQuitAllowed 是false,是不允许退出
if (!mQuitAllowed) {
throw new IllegalStateException("Main thread not allowed to quit.");
}
synchronized (this) {
//判断是否已经退出
if (mQuitting) {
return;
}
//标记为已退出状态,只用这个位置能标记
mQuitting = true;
//两种清除队列中消息的方法
if (safe) {
removeAllFutureMessagesLocked();
} else {
removeAllMessagesLocked();
}
// 注销
nativeWake(mPtr);
}
}
这里有两种退出方式： removeAllFutureMessagesLocked() 被认为是一种安全的退出方式，removeAllMessagesLocked()被认为是不安全的。
private void removeAllFutureMessagesLocked() {
final long now = SystemClock.uptimeMillis();
Message p = mMessages;//队列中的头Header
if (p != null) { //队列不为空
if (p.when > now) {
//当前没有可执行的Message,直接删除
removeAllMessagesLocked();
} else {
Message n;
//通过for循环找到执行时间大于当前时间的
for (;;) {
n = p.next;
if (n == null) {
return;
}
if (n.when > now) {
break;
}
p = n;
}
p.next = null;
do {
//将行时间大于当前时间的所有Message通过循环回收掉
p = n;
n = p.next;
p.recycleUnchecked();
} while (n != null);
}
}
}
通过上面可以看到当队列中当前Message中when时间都大于当前时间时，直接全部删除，有需要执行的，排除掉执行的，删除其余的。
private void removeAllMessagesLocked() {
Message p = mMessages; //消息队列的Header
while (p != null) { //循环删除所有Message
Message n = p.next;
p.recycleUnchecked(); //回收Message
p = n;
}
mMessages = null;
}
removeAllMessagesLocked 代码比较简单，就是直接删除
异步消息和消息屏障
异步消息
Handler中有一个mAsynchronous变量，true是表示发送一个异步消息，false表示一个同步消息，是否是异步消息最终是调用Message中的
public void setAsynchronous(boolean async) {
if (async) {
flags |= FLAG_ASYNCHRONOUS;
} else {
flags &= ~FLAG_ASYNCHRONOUS;
}
}
消息屏障
消息屏障也称为同步屏障，是为了让某些特殊消息得以更快执行的机制。这套机制是用来优先处理某些消息的，比如试图刷新。
外部实现设置消息屏障是通过postSyncBarrier。
public int postSyncBarrier() {
return postSyncBarrier(SystemClock.uptimeMillis());
}
private int postSyncBarrier(long when) {
//同步方法，线程安全
synchronized (this) {
//统计屏障消息的数量，也是记录token
final int token = mNextBarrierToken++;
//生成一个空的Message消息
final Message msg = Message.obtain();
msg.markInUse();
msg.when = when;
msg.arg1 = token;
//将msg根据when插入到消息队列中
Message prev = null;
Message p = mMessages;//消息队列的头部
if (when != 0) {
while (p != null && p.when <= when) {
prev = p;
p = p.next;
}
}
if (prev != null) { // invariant: p == prev.next
msg.next = p;
prev.next = msg;
} else {
msg.next = p;
mMessages = msg;
}
return token;
}
}
添加一个消息屏障做了以下几件事：
1.添加一个序列号
2.生产一个没有targ的Message
3.把Message加入队列中
清除消息屏障：
public void removeSyncBarrier(int token) {
// Remove a sync barrier token from the queue.
// If the queue is no longer stalled by a barrier then wake it.
synchronized (this) {
Message prev = null;
Message p = mMessages;
//通过while循环,找出token匹配的Message 或者 没有target的
while (p != null && (p.target != null || p.arg1 != token)) {
prev = p;
p = p.next;
}
if (p == null) {
throw new IllegalStateException("The specified message queue synchronization "
+ " barrier token has not been posted or has already been removed.");
}
final boolean needWake;
if (prev != null) {
prev.next = p.next;
needWake = false;
} else {
mMessages = p.next;
needWake = mMessages == null || mMessages.target != null;
}
p.recycleUnchecked();
// If the loop is quitting then it is already awake.
// We can assume mPtr != 0 when mQuitting is false.
if (needWake && !mQuitting) {
nativeWake(mPtr);
}
}
}
消息屏障的使用
从上面的代码可以看出消息屏障还是一个Message，那边执行时应该是在next方法中
Message next() {
// Return here if the message loop has already quit and been disposed.
// This can happen if the application tries to restart a looper after quit
// which is not supported.
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);
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) { //消息屏障的一个特点就是,msg.target == null
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous()); //循环寻找异步消息,当找不到异步消息,最终msg == null
}
/**
*省略部分代码
**/
从上面可以看到，next方法首先判断Header是不是消息屏障，如果是的话就检查有没有异步消息，如果有，就直接执行异步消息，没有就进入阻塞状态。
如果队列里面有异步消息 则取出此异步消息返回 然后继续阻塞线程 ， 直到移除屏障消息(这里才会触发唤醒线程)。
没有异步消息则继续阻塞 ，直到调用removeSyncBarrier移除屏障那么才会取出这个普通消息 返回。
从这里可以看出，消息屏障和异步消息是协作进行的，消息屏障的功能也就是确保异步消息能被优先执行。
Handler常见面试题
1.Looper.loop方法是死循环，为什么不会卡死
首先我们描述以下ANR的原因，ANR是程序无响应。Android系统对于一些事情需要在一定范围内完成，如果超出预定时间任未能得到有效处理或者相应时间过长，就会造成ANR。在主线程之外，会有其它线程来处理其它进程的事件，比如Binder线程。
当没有消息的时候，会阻塞在loop的queue.next中的nativePollonce()方法里，此时主线程会释放CPU资源进入休眠状态，直到下一个消息到达或者食物发生，所有死循环也不会特别消耗资源。
Handler.Callback.handleMessage 和 Handler.handleMessage 有什么不一样？为什么这么设计？
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
从上面代码可以看出，优先执行msg.callback，也就是Handler.post,没有msg.callback 时，才考虑执行mCallback 和handleMessage，如果Callback.handleMessage返回true，就不执行handleMessage了。
Handler、Looper、MessageQueue、线程是一一对应关系吗？
一个线程中只能有一个Looper和MessageQueue,MessageQueue是在Looper的构造函数中初始化的,Looper和MessageQueue一一对应，而Hanlder是能够创建多个的，所以Handler对于Looper是可以多对一的，也就是多个Hanlder对象都可以用同一个线程、同一个Looper、同一个MessageQueue。
Handler会导致内存泄漏吗？怎么解决内存泄漏？
1.Handler会导致内存泄漏，因为使用内部类创建Handler的时候，内部类会持有外部内对象，所以Handler对象会持有外部内对象，而Message中的targe就是Handler对象，Message又存放到MessageQueue中，所以当Message没有被执行的时候就会导致Activity无法被回收。
ActivityThread -> ThreadLocal->Looper->MessageQueue->Message->Handler
->Activity
2.解决方法
1）创建Handler时，使用static修饰 + 弱引用，静态内部类不会持有外部类对象
2）在在 Activity 被销毁时及时清除消息（Handler.removeCallbacksAndMessages），从而及时回收 Activity，避免内存泄漏问题。
