Android Handler之同步屏障机制

1.Message消息分类

Handler的Message消息分为3种：普通消息(同步消息)、屏障消息(同步屏障)、异步消息。

通常Handler使用的都是普通消息，而屏障消息就是在消息队列中插入一个屏障，在屏障之后的所有普通消息都会被挡着，不能被处理。但是异步消息却例外，屏障不会挡住异步消息。因此可以理解为：屏障消息就是为了确保异步消息的优先级，设置了屏障后，只能处理其后的异步消息，同步消息会被挡住，除非撤销屏障。

 

2.发送异步消息

一般使用Handler发消息时都是同步消息，要发送异步消息有两种方式：

①通过Handler实现

Handler的构造方法中有个async参数，默认的构造方法中此参数为false，如果想发送异步消息，需要在创建Handler时使用以下构造函数并把async赋值为true。

public Handler(boolean async);

public Handler(Callback callback, boolean async);

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

参数async设置为true后，Handler类中的全局变量mAsynchronous就会置为true，然后在enqueueMessage()方法里就会调用msg.setAsynchronous(true)将message设置为异步的。

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

    msg.target = this;

    if (mAsynchronous) {

        msg.setAsynchronous(true);

    }

    return queue.enqueueMessage(msg, uptimeMillis);

}

通过该Handler发送的所有消息都是异步消息。

②通过Message实现

在创建Message对象时，直接调用Message的setAsynchronous()方法。

在一般情况下异步消息和同步消息没有什么区别，但是一旦开启了同步屏障以后就有区别了。

 

2.发送屏障消息

屏障消息（同步屏障）是通过MessageQueue的postSyncBarrier()方法插入到消息队列的。

public final class MessageQueue {

    public int postSyncBarrier() {

        return postSyncBarrier( SystemClock.uptimeMillis()); // 从开机到现在的时间戳

    }

    private int postSyncBarrier(long when) {

        synchronized (this) {

            //第一步，获取屏障的的唯一标示token，标示从0开始，自加1

             final int token = mNextBarrierToken++;

            //第二步，创建屏障消息，设置msg为正在使用状态，并重置msg的when和arg1，arg1的值设置为token值。注意这里并没有给tareget赋值。所以msg的target是否为空是判断这个msg是否是屏障消息的标志

            final Message msg = Message.obtain();

            msg.markInUse();

            msg.when = when;

            msg.arg1 = token;

            //第三步，创建变量pre和p，为下一步做准备。其中p被赋值为mMessages，指向消息队列中的第一个元素

            Message prev = null; 

            Message p = mMessages; 

            //第四步，通过对队列中的第一个Message的when和屏障的when进行比较，决定屏障消息在整个消息队列中的位置，因为消息队列中的消息都是按时间排序的

            if (when != 0) {

                while (p != null && p.when <= when) { //如果开启同步屏障的时间T不为0，且当前的同步消息里有时间小于T，则prev也不为null 

                    prev = p;

                    p = p.next;

                }

            }   

            //第五步，prev != null说明屏障消息不是插入消息的头部，把msg插入到消息队列中

            if (prev != null) { 

                msg.next = p;

                prev.next = msg;

            } else { //第六步，prev == null代表是消息队列的头部，把msg插入消息的头部

                msg.next = p;

                mMessages = msg;

            }

            //最后，返回一个序号，通过这个序号可以撤销屏障

            return token;

        }

    }

}

屏障消息初始化时并没有给target赋值，因此target==null的来源就找到了。这样就插入了一条target==null的消息，这个消息就是一个同步屏障。

 

发送同步/异步消息与发送屏障消息的区别：

一般使用handler.sendMessage()发送同步/异步消息，最终会调用Handler的enqueueMessage()方法将消息插入消息队列：

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

    msg.target = this;

    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类型的数值，通过这个数值可以撤销屏障。

④postSyncBarrier()方法是私有的，如果想调用它就得使用反射。

⑤插入普通消息会唤醒消息队列，但是插入屏障不会。

 

3.根据消息屏障取出异步消息

屏障消息通过postSyncBarrier()方法被插入到消息队列中，那么屏障是如何挡住普通消息，只允许异步消息通过的呢？

Handler的消息处理是通过Looper.loop()从消息队列中获取消息然后交给Handler处理的，其中获取消息是通过MessageQueue的next方法：

public final class MessageQueue {

    Message next() {

        for(; ;) {

            //1、如果有消息被插入到消息队列或者超时时间到，就被唤醒，否则阻塞在这

            nativePollOnce(ptr, nextPollTimeoutMillis);

            synchronized (this) {

                Message prevMsg = null;//前一个msg

                Message msg = mMessages;//首个msg

               if (msg != null && msg.target == null) { //2、msg.target == null说明当前队首消息是屏障消息，这时需要遍历，一直往后找到第一个异步消息，即msg.isAsynchronous()为true，或message到末尾了。这个target==null的消息不会被取出处理，它会一直存在。每次处理异步消息时都会从头开始轮询，都需要经历从msg.target开始的遍历

                    do {

                        prevMsg = msg;

                        msg = msg.next;

                    } while (msg != null && !msg.isAsynchronous()); //3、遍历消息链表找到最近的一条异步消息

                }

                if (msg != null) { //4、找到了最近的异步消息或者没遇到屏障消息

                    if (now < msg.when) { //先判断时间有没有到，如果没到的话设置阻塞时间

                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE); //计算出离执行时间还有多久，赋值给nextPollTimeoutMillis，表示nativePollOnce方法要等待nextPollTimeoutMillis时长后返回

                    } else { //到了处理时间，就从链表移除，并返回它

                        mBlocked = false;

                        if (prevMsg != null) { 

                            prevMsg.next = msg.next;

                        } else {

                            mMessages = msg.next;

                        }

                        msg.next = null;

                        msg.markInUse();

                        return msg;

                    }

                } else { //没有消息就一直休眠，等待被唤醒，nextPollTimeoutMillis复位

                    nextPollTimeoutMillis = -1;

                }

            }

        }

    }

}

msg.target == null说明该msg是屏障消息，此时会进入到循环，遍历移动msg的位置，直到移动到的msg是异步消息则退出循环，也就是说循环的代码会过滤掉所有的同步消息，直到取出异步消息为止。在遍历的过程中只有异步消息才会被处理执行到if (msg != null){}中的代码。屏障消息就是通过这种方式就挡住了所有的普通消息。

所以当设置了同步屏障之后，next函数将会忽略所有的同步消息，返回异步消息。也就是说设置了同步屏障之后Handler只会处理异步消息。

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

在消息队列中有同步消息和异步消息（黄色）以及同步屏障（红色）。有了同步屏障的存在，msg_2和msg_M这两个异步消息可以被优先处理，而后面的msg_3等同步消息则不会被处理，只有移除这个同步屏障后msg_3等同步消息才可以被处理。

 

4.移除消息屏障

同步屏障的移除是在MessageQueue类的removeSyncBarrier()方法里。

public final class MessageQueue {

    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;

            // 删除屏障消息p

            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界面的流畅刷新。