1.Message消息分类
Handler的Message消息分为3种：普通消息(同步消息)、屏障消息(同步屏障)、异步消息。
通常Handler使用的都是默认普通消息，而屏障消息就是在消息队列中插入一个屏障，在屏障之后的所有普通消息都会被挡着，不能被处理。但是异步消息却例外，屏障不会挡住异步消息。因此可以理解为：屏障消息就是为了确保异步消息的优先级，设置了屏障后，只能处理其后的异步消息，同步消息会被挡住，除非撤销屏障。
2.发送异步消息
一般使用Handler发消息时都是同步消息，要发送异步消息有两种方式：
①通过Handler实现
Handler的构造方法中有个async参数，默认的构造方法中此参数为false，如果想发送异步消息，需要在创建Handler时使用以下构造函数并把async赋值为true。
public Handler(boolean async) {
this(null, async);
} ②通过Message实现
在创建Message对象时，直接调用Message的setAsynchronous()方法。
public void setAsynchronous(boolean async) {
if (async) {
flags |= FLAG_ASYNCHRONOUS;
} else {
flags &= ~FLAG_ASYNCHRONOUS;
}
} 在一般情况下异步消息和同步消息没有什么区别，但是一旦开启了同步屏障以后就有区别了。
2.发送屏障消息
屏障消息（同步屏障）是通过MessageQueue的postSyncBarrier()方法插入到消息队列的。
public int postSyncBarrier() {
return postSyncBarrier(SystemClock.uptimeMillis());
}
public int postSyncBarrier() {
return postSyncBarrier(SystemClock.uptimeMillis());
} private int postSyncBarrier(long when) {
// Enqueue a new sync barrier token.
// We don't need to wake the queue because the purpose of a barrier is to stall it.
synchronized (this) {
final int token = mNextBarrierToken++;
final Message msg = Message.obtain();
msg.markInUse();
msg.when = when;
msg.arg1 = token;
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;
}
} 屏障消息初始化时并没有给target赋值，因此target==null的来源就找到了。这样就插入了一条target==null的消息，这个消息就是一个同步屏障。
发送同步/异步消息与发送屏障消息的区别：
一般使用handler.sendMessage()发送同步/异步消息，最终会调用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);
} enqueueMessage()方法里为msg设置了target字段，即发送同步/异步消息到消息队列时都为message设置了target属性。
而发送屏障消息时使用的是postSyncBarrier()，该方法也是从Message消息对象池中获取一个msg插入到消息队列中，唯一不同的是没有设置target字段。所以屏障消息就是一个target为空的Message。
总结一下：
①屏障消息和普通消息的区别在于屏障消息没有tartget属性。普通消息有target是因为它需要将消息分发给对应的target，而屏障不需要被分发，它就是用来挡住普通消息来保证异步消息优先处理的。
②屏障消息和普通消息一样需要根据时间插入到消息队列中的适当位置，并且只会挡住它后面的同步消息的分发。
③postSyncBarrier()返回一个int类型的数值，通过这个数值可以撤销屏障。
④插入普通消息会唤醒消息队列，但是插入屏障不会。
3.根据消息屏障取出异步消息
屏障消息通过postSyncBarrier()方法被插入到消息队列中，那么屏障是如何挡住普通消息，只允许异步消息通过的呢？
Handler的消息处理是通过Looper.loop()从消息队列中获取消息然后交给Handler处理的，其中获取消息是通过MessageQueue的next方法：
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);
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != 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());
}
if (msg != null) {
if (now < msg.when) {
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
// Process the quit message now that all pending messages have been handled.
if (mQuitting) {
dispose();
return null;
}
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 {
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
}
} msg.target == null说明该msg是屏障消息，此时会进入到循环，遍历移动msg的位置，直到移动到的msg是异步消息则退出循环，也就是说循环的代码会过滤掉所有的同步消息，直到取出异步消息为止。在遍历的过程中只有异步消息才会被处理执行到if (msg != null){}中的代码。屏障消息就是通过这种方式就挡住了所有的普通消息。
所以当设置了同步屏障之后，next函数将会忽略所有的同步消息，返回异步消息。也就是说设置了同步屏障之后Handler只会处理异步消息。
所以说同步屏障为Handler消息机制增加了一种简单的优先级机制，异步消息的优先级要高于同步消息。
有了同步屏障的存在，异步消息可以被优先处理，而后面的同步消息则不会被处理，只有移除这个同步屏障后剩下的同步消息才可以被处理。
4.移除消息屏障
同步屏障的移除是在MessageQueue类的removeSyncBarrier()方法里。
public void removeSyncBarrier(int token) {
synchronized (this) {
Message prev = null;
Message p = mMessages;
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 (needWake && !mQuitting) {
nativeWake(mPtr);
}
}
}
不断遍历消息队列，直到找到屏障消息，退出循环的条件有两个，一是p.target == null，说明是屏障消息，二是p.arg1 == token，也说明p是屏障消息，因为在屏障消息入队的时候设置过msg.arg1 = token。找到屏障消息后，把它从消息队列中删除并回收。
所以，移除一个消息屏障就做了2件事：
①移除此序列号的token消息
②如果主线程是阻塞状态，则唤醒线程
5.同步屏障的应用
Android系统中UI更新相关的消息即为异步消息，需要优先处理。每16ms左右刷新一次UI，即1s刷新60次。Android4.1之后增加了Choreographer机制，用于同Vsync机制配合，统一动画、输入和绘制时机。
ViewRootImpl的requestLayout开启绘制流程：
public final class ViewRootImpl implements ViewParent, … {
@Override
public void requestLayout() {
if (!mHandlingLayoutInLayoutRequest) {
checkThread();//检查是否在主线程
mLayoutRequested = true;
scheduleTraversals(); //重要函数
}
}
} 应用框架中为了更快的响应UI刷新事件，在ViewRootImpl.scheduleTraversals中使用了同步屏障：
public final class ViewRootImpl implements ViewParent, … {
void scheduleTraversals() {
if (!mTraversalScheduled) {
mTraversalScheduled = true;
mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier(); //设置同步障碍，确保下面发送的mTraversalRunnable优先被执行
mChoreographer.postCallback( Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null); //内部通过Handler发送了一个异步消息（前面设置了同步屏障，所以这里发的异步消息会优先执行）
notifyRendererOfFramePending();
pokeDrawLockIfNeeded();
}
}
} mChoreographer.postCallback会执行到Choreographer类中：
public final class Choreographer {
public void postCallback(int callbackType, Runnable action, Object token) {
postCallbackDelayed(callbackType, action, token, 0);
}
public void postCallbackDelayed(int callbackType, Runnable action, Object token, long delayMillis) {
postCallbackDelayedInternal( callbackType, action, token, delayMillis);
}
private void postCallbackDelayedInternal(int callbackType, Object action, Object token, long delayMillis) {
synchronized (mLock) {
final long now = SystemClock.uptimeMillis();
final long dueTime = now + delayMillis;
mCallbackQueues[callbackType].addC allbackLocked(dueTime, action, token);
if (dueTime <= now) {
scheduleFrameLocked(now);
} else { // 发送异步消息
Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
msg.arg1 = callbackType;
msg.setAsynchronous(true);//异步消息
mHandler.sendMessageAtTime(msg, dueTime);
}
}
}
} mTraversalRunnable调用了performTraversals执行measure、layout、draw绘制UI。为了让mTraversalRunnable尽快被执行，在发消息之前调用MessageQueue.postSyncBarrier设置了同步屏障。
scheduleTraversals方法开启了同步屏障，并且发送了异步消息，由于UI相关的消息是优先级最高的，这样系统就会优先处理这些异步消息。
最后，要移除同步屏障的时候，会调用ViewRootImpl的unscheduleTraversals方法：
public final class ViewRootImpl implements ViewParent, … {
void unscheduleTraversals() {
if (mTraversalScheduled) {
mTraversalScheduled = false;
// 移除同步屏障
mHandler.getLooper().getQueue().remo veSyncBarrier(mTraversalBarrier);
mChoreographer.removeCallbacks( Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
}
}
}
在ViewRootImpl中的doTraversal()方法中会移除同步屏障，这里移除是因为requestLayout或者invalidate的时候，刷新之后，在doTraversal()中就会移除同步屏障，因为此时消息已经发送并且处理了。
总结一下，ViewRootImpl在处理UI事件之前，先发送一个屏障消息，告诉handler优先处理异步消息，然后Choreographer发送异步消息，异步消息处理完以后，然后再发送一个移除异步屏障的消息。Handler就通过这种机制保障了UI界面的流畅刷新。