一、概述

简单理解为 异步消息插队并优先执行。

场景：排队买票

先来了一个普通用户来排队，买完票走了。

后面又来了一个VIP用户A来买票 就一直站在卖窗口这里 也不走(ps：添加屏障 )

紧接者又来了一个普通用户C，再后面又来了VIP用户B

VIP A 对VIP B 说，哥们不要排队直接来窗口买票，VIP B买完票走了，VIP A 被 某个哥们叫走了(移除屏障)

这个时候终于轮到普通用户C买票了。

二、系统应用

简单的来说就是优于事件回调执行，为了做一些优先级更高的操作 比如 视图刷新。当一个Handler消息来时 会优先于执行同步屏障消息事件。

以便系统底层可以做一些比上层业务更加重要的消息事件 ，所以 这个方法 被注解成hide 也是系统给自己开了一道后门。不然的话把方法公开给应用去使用，那么很可能把系统卡成翔而导致掉帧。

申请VSYNC信号前加入屏障，保证被优先执行

这里的handler就是主线程的handler

void scheduleTraversals() {

if (!mTraversalScheduled) {

mTraversalScheduled = true;

//设置同步障碍，确保mTraversalRunnable优先被执行

mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();

//内部持有Handler关联主looper, 然后通过Handler发送了一个异步消息到主线程messageQueue

mChoreographer.postCallback(

Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);

。。。。

}

}

以上说明申请VSYNC信号非常重要，如果申请VSYNC不及时会造成屏幕不流畅卡顿现象，所以说Android是不允许在主线程做耗时操作的一个重要原因，因为当前一个消息正在onHandlerMesage中(main)做耗时操作，那么VSYNC申请会处于一个等待状态 造成屏幕无法在16.6ms内刷新(一般来说屏幕刷新频率 主流为60Hz ,也就是16.6ms刷新一次)。

回调后：

自己被执行了才移除屏障

进行View的绘制流程

void doTraversal() {

if (mTraversalScheduled) {

mTraversalScheduled = false;

//移除消息屏障

mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);

if (mProfile) {

Debug.startMethodTracing("ViewAncestor");

}

performTraversals();

if (mProfile) {

Debug.stopMethodTracing();

mProfile = false;

}

}

}

三、源码实现

3.1 Message分类

Handler中的Message可以分为两类：同步消息、异步消息。消息类型可以通过以下函数得知

//Message.java

public boolean isAsynchronous() {

return (flags & FLAG_ASYNCHRONOUS) != 0;

}

一般情况下这两种消息的处理方式没什么区别，只有在设置了同步屏障时才会出现差异。

3.2 MessageQueue的特殊处理

3.2.1 MessageQueue.postSyncBarrier

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;

}

}

该函数仅仅是创建了一个Message对象并加入到了消息链表中。乍一看好像没什么特别的，但是这里面有一个很大的不同点是 该Message没有target, 这也就意味着被looper取出后不经过handler执行。

和普通消息的差异：没有targer:Handler

我们通常都是通过Handler发送消息的，Handler中发送消息的函数有post***、sendEmptyMessage***以及sendMessage***等函数，而这些函数最终都会调用enqueueMessage函数：可以看到enqueueMessage为msg设置了target字段

//Handler.java

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {

msg.target = this;

//...

return queue.enqueueMessage(msg, uptimeMillis);

}

然后在looper中转发给Handler处理：

public static void loop() {

final Looper me = myLooper();

final MessageQueue queue = me.mQueue;

for (;;) {

//取出消息，没有消息则阻塞

Message msg = queue.next();

msg.target.dispatchMessage(msg);

}

}

和普通消息的差异：空消息，不唤醒线程

注意的是 添加消息屏障并没有调用 nativeWake(mPtr) 来唤醒线程。

而通过enqueueMessage 消息是有去调用nativeWake(mPtr) 来唤醒线程的。(ps:当主线程阻塞状态 才会触发nativeWake)

很好理解：屏障只是为了后续加入的异步信息，如果没有信息就不需要唤醒线程，有信息自然就会走enqueueMessage唤醒

3.2.2 MessageQueue.next

Message next() {

//...

int pendingIdleHandlerCount = -1; // -1 only during first iteration

int nextPollTimeoutMillis = 0;

for (;;) {

//...

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) {//碰到同步屏障

// Stalled by a barrier. Find the next asynchronous message in the queue.

// do while循环遍历消息链表

// 跳出循环时，msg指向离表头最近的一个“非同步消息”，没有就会为null

do {

prevMsg = msg;

msg = msg.next;

} while (msg != null && !msg.isAsynchronous());

}

if (msg != null) {

if (now < msg.when) {

//...

} else {

// Got a message.

mBlocked = false;

if (prevMsg != null) {

//将msg从消息链表中移除

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;

}

//...

}

//...

}

}

当设置了同步屏障之后，next函数将会忽略所有的同步消息，返回异步消息。

也就是说，如果第一条消息就是屏障，那么就往后遍历 看看有没有异步消息

有 ：再看离这个消息触发 还有多久，设置一个超时继续休眠

没有：就继续休眠，等待被别人唤醒，此时该屏障一直存在在消息队列头部

换句话说就是，设置了同步屏障SyncBarrier之后，Handler只会处理isAsynchronous异步消息。

再换句话说，同步屏障为Handler消息机制增加了一种简单的优先级机制，异步消息的优先级要高于同步消息。

3.2.3 MessageQueue.removeSyncBarrier移除屏障

public void removeSyncBarrier(int token) {

// Remove a sync barrier token from the queue.

//....省略.......移除队列中barrier的token消息

//唤醒线程

if (needWake && !mQuitting) {

nativeWake(mPtr);

}

}

}

移除一个消息屏障，做了以下几件事：

1.移除次序列号的token消息

2.如果主线程是阻塞状态，则唤醒线程

3.3 Handler发送异步信息

如何发送异步消息

通常我们使用Handler发消息时，这些消息都是同步消息，如果我们想发送异步消息，那么在创建Handler时使用以下构造函数中的其中一种(async传true)

public Handler(boolean async);

public Handler(Callback callback, boolean async);

public Handler(Looper looper, Callback callback, boolean async);

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {

msg.target = this; //target 是不会为null的

if (mAsynchronous) {// 默认为false ，消息默认是被标记为同步(普通)消息

msg.setAsynchronous(true);

}

return queue.enqueueMessage(msg, uptimeMillis);

}

然后通过该Handler发送的所有消息都会变成异步消息

四、总结

一般屏障是和异步 是一起配合使用的，直到调用removeSyncBarrier 那么后面的普通消息才有机会执行；

被 Message ： p.target 的被标记为屏障消息。

被setAsynchronous(true) 为异步消息 ；

当我们利用handler 发送消息的时候，根据Handler的属性判断是否发送异步信息：

Handler:postSyncBarrier 和 removeSyncBarrier 方法都是被@hide ，是无法直接调用的，需通过反射来使用；

postSyncBarrier 不会唤醒线程， removeSyncBarrier 会唤醒线程(当队列里面有消息时)；

具体流程如下：

只要遍历到一个屏障消息 ，那么相当于再这个时间添加了屏障(这里不会主动唤醒线程) ，那么后面入队的异步消息 都优先执行

没有则一直阻塞，如果这个时候一个普通消息sendMessageDelayed(getPostMessage®, 0)入队 会触发唤醒线程。

如果队列里面有异步消息 则取出此异步消息返回 然后继续阻塞线程 ，直到移除屏障消息(这里才会触发唤醒线程)。

如果队列里面没有异步消息则继续阻塞 ，直到调用removeSyncBarrier移除屏障那么才会取出这个普通消息 返回。

参考文献