Android Handler 机制（四）：屏障消息（同步屏障sync barrier，异步消息 ）IdelHandler

总结：

1. 同步屏障可以通过MessageQueue.postSyncBarrier函数来设置。该方法发送了一个没有target的Message到Queue中。
2. 在next方法中获取消息时，如果发现没有target的Message，则在一定的时间内跳过同步消息，优先执行异步消息。
3. 再换句话说，同步屏障为Handler消息机制增加了一种简单的优先级机制，异步消息的优先级要高于同步消息。
4. 在创建Handler时有一个async参数，传true表示此handler发送的时异步消息。ViewRootImpl.scheduleTraversals方法就使用了同步屏障，保证UI绘制优先执行。

同步屏障机制是一套为了让某些特殊的消息得以更快被执行的机制。

一、Handler Message 种类

Handler的Message种类分为3种：

• 普通消息
• 屏障消息
• 异步消息

其中普通消息又称为同步消息，屏障消息又称为同步屏障。

屏障消息就是为了确保异步消息的优先级，设置了屏障后，只能处理其后的异步消息，同步消息会被挡住，除非撤销屏障。

二、屏障消息如何插入消息队列

如上图所示，在消息队列中有同步消息和异步消息（黄色部分）以及一道墙----同步屏障（红色部分）。有了同步屏障的存在，msg_2 和 msg_M 这两个异步消息可以被优先处理，而后面的 msg_3 等同步消息则不会被处理。那么这些同步消息什么时候可以被处理呢？那就需要先移除这个同步屏障，即调用removeSyncBarrier()。

我们的手机屏幕刷新频率有不同的类型，60Hz、120Hz等。60Hz表示屏幕在一秒内刷新60次，也就是每隔16.6ms刷新一次。

• 屏幕会在每次刷新的时候发出一个 VSYNC 信号，通知CPU进行绘制计算。
• 具体到我们的代码中，可以认为就是执行onMesure()、onLayout()、onDraw()这些方法。好了，大概了解这么多就可以了。

了解过 view 绘制原理的读者应该知道，view绘制的起点是在 viewRootImpl.requestLayout() 方法开始，这个方法会去执行上面的三大绘制任务，就是测量布局绘制。但是，重点来了：

调用requestLayout()方法之后，并不会马上开始进行绘制任务，而是会给主线程设置一个同步屏障，并设置 ASYNC 信号监听。当 ASYNC 信号的到来，会发送一个异步消息到主线程Handler，执行我们上一步设置的绘制监听任务，并移除同步屏障。

这里我们只需要明确一个情况：调用requestLayout()方法之后会设置一个同步屏障，知道ASYNC信号到来才会执行绘制任务并移除同步屏障。

api29
   @Override
    public void requestLayout() {
        if (!mHandlingLayoutInLayoutRequest) {
            checkThread();
            mLayoutRequested = true;
            scheduleTraversals();//发送同步屏障
        }
    }

那，这样在等待ASYNC信号的时候主线程什么事都没干？是的。这样的好处是：保证在ASYNC信号到来之时，绘制任务可以被及时执行，不会造成界面卡顿。但这样也带来了相对应的代价：

• 我们的同步消息最多可能被延迟一帧的时间，也就是16ms，才会被执行
• 主线程Looper造成过大的压力，在VSYNC信号到来之时，才集中处理所有消息

改善这个问题办法就是：使用异步消息。当我们发送异步消息到MessageQueue中时，在等待VSYNC期间也可以执行我们的任务，让我们设置的任务可以更快得被执行且减少主线程Looper的压力。

异步消息机制本身就是为了避免界面卡顿，那我们直接使用异步消息，会不会有隐患？这里我们需要思考一下，什么情况的异步消息会造成界面卡顿：异步消息任务执行过长、异步消息海量。

如果异步消息执行时间太长，那即时是同步任务，也会造成界面卡顿，这点应该都很好理解。其次，若异步消息海量到达影响界面绘制，那么即使是同步任务，也是会导致界面卡顿的；原因是MessageQueue是一个链表结构，海量的消息会导致遍历速度下降，也会影响异步消息的执行效率。所以我们应该注意的一点是：

不可在主线程执行重量级任务，无论异步还是同步。

那，我们以后岂不是可以直接使用异步Handler来取代同步Handler了？是，也不是。

• 同步Handler有一个特点是会遵循与绘制任务的顺序，设置同步屏障之后，会等待绘制任务完成，才会执行同步任务；
• 而异步任务与绘制任务的先后顺序无法保证，在等待VSYNC的期间可能被执行，也有可能在绘制完成之后执行。
• 建议是：如果需要保证与绘制任务的顺序，使用同步Handler；其他，使用异步Handler。

在Android系统里面为了更快响应UI刷新在ViewRootImpl.scheduleTraversals也有应用：

   android.view.ViewRootImpl#scheduleTraversals
    void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            //开启同步屏障
            mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
            //发送异步消息
            mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
            if (!mUnbufferedInputDispatch) {
                scheduleConsumeBatchedInput();
            }
            notifyRendererOfFramePending();
            pokeDrawLockIfNeeded();
        }
    }

postCallback()最终走到了ChoreographerpostCallbackDelayedInternal()：

		最后调用 android.os.MessageQueue#enqueueMessage
		boolean enqueueMessage(Message msg, long when) {}

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

MessageQueue中的Message，有一个变量isAsynchronous，他标志了这个Message是否是异步消息；标记为true称为异步消息，标记为false称为同步消息。
同时还有另一个变量target，标志了这个Message最终由哪个Handler处理。

MessageQueue#postSyncBarrier方法的源码如下：
重点在于：
没有给Message赋值target属性，且插入到Message队列头部。
这个target==null的特殊Message就是同步屏障。

android.os.MessageQueue#postSyncBarrier()
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++;
            //1、屏障消息和普通消息的区别是屏障消息没有tartget。
            final Message msg = Message.obtain();
            msg.markInUse();
            msg.when = when;
            msg.arg1 = token;

            Message prev = null;
            Message p = mMessages;
            //2、根据时间顺序将屏障插入到消息链表中适当的位置
            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;
            }
            //3、返回一个序号，通过这个序号可以撤销屏障
            return token;
        }
}

postSyncBarrier返回一个int类型的数值，通过这个数值可以撤销屏障。
postSyncBarrier方法是私有的，如果我们想调用它就得使用反射。
插入普通消息会唤醒消息队列，但是插入屏障不会。

添加异步消息有两种办法：

• 使用异步类型的Handler发送的全部Message都是异步的
• 给Message标志异步.

   public Handler(boolean async) {
        this(null, async);
    }
   final boolean mAsynchronous;
   if (mAsynchronous) {
            msg.setAsynchronous(true);
   }

异步类型的Handler构造器是标记为hide，我们无法使用，但在api28之后添加了两个重要的方法：
通过这两个api就可以创建异步Handler了，而异步Handler发出来的消息则全是异步的。

public static Handler createAsync(@NonNull Looper looper) {
    if (looper == null) throw new NullPointerException("looper must not be null");
    return new Handler(looper, null, true);
}


public static Handler createAsync(@NonNull Looper looper, @NonNull Callback callback) {
    if (looper == null) throw new NullPointerException("looper must not be null");
    if (callback == null) throw new NullPointerException("callback must not be null");
    return new Handler(looper, callback, true);
}

public void setAsynchronous(boolean async) {
    if (async) {
        flags |= FLAG_ASYNCHRONOUS;
    } else {
        flags &= ~FLAG_ASYNCHRONOUS;
    }

三、屏障消息的工作原理

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

我们知道MessageQueue是通过next方法来获取消息的。

注意，同步屏障不会自动移除，使用完成之后需要手动进行移除，不然会造成同步消息无法被处理。我们可以看一下源码：

Message next() {
    // 阻塞对应时间 
    //1、如果有消息被插入到消息队列或者超时时间到，就被唤醒，否则阻塞在这。
    nativePollOnce(ptr, nextPollTimeoutMillis);
    synchronized (this) {
        Message prevMsg = null;
        Message msg = mMessages;
        if (msg != null && msg.target == null) {//2、遇到屏障  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());//3、遍历消息链表找到最近的一条异步消息
        }
        if (msg != null) {
            //4、如果找到异步消息
            if (now < msg.when) {//异步消息还没到处理时间，就在等会（超时时间）
                                    // Next message is not ready.  Set a timeout to wake up when it is ready.
                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;
                if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                msg.markInUse();
                return msg;
            }
        } else {
            // 如果没有异步消息就一直休眠，等待被唤醒。
            nextPollTimeoutMillis = -1;
        }
         // Process the quit message now that all pending messages have been handled.
                if (mQuitting) {
                    dispose();
                    return null;
                }

                // If first time idle, then get the number of idlers to run.
                // Idle handles only run if the queue is empty or if the first message
                // in the queue (possibly a barrier) is due to be handled in the future.
                 // 获取IdleHandler个数
                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;
                }
                
				// 添加IdleHandler到准备处理的队列
                if (mPendingIdleHandlers == null) {
                    mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
                }
                mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
            }

            // Run the idle handlers.
            // We only ever reach this code block during the first iteration.
            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 {
                  // 调用 Idle接口
                    keep = idler.queueIdle();
                } catch (Throwable t) {
                    Log.wtf(TAG, "IdleHandler threw exception", t);
                }

                if (!keep) {
                    synchronized (this) {
                    // 移除IdleHandler
                        mIdleHandlers.remove(idler);
                    }
                }
            }

            // Reset the idle handler count to 0 so we do not run them again.
            pendingIdleHandlerCount = 0;

            // While calling an idle handler, a new message could have been delivered
            // so go back and look again for a pending message without waiting.
            nextPollTimeoutMillis = 0;
    }
}

四 移除同步屏障

最后，当要移除同步屏障的时候需要调用ViewRootImpl#unscheduleTraversals()。

ViewRootImpl#unscheduleTraversals()。
    void unscheduleTraversals() {
        if (mTraversalScheduled) {
            mTraversalScheduled = false;
            //移除同步屏障
            mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);
            mChoreographer.removeCallbacks(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
        }
    }

MessageQueue的removeSyncBarrier方法
在removeSyncBarrier方法中，首先是去寻找屏障消息，找不到会抛出异常；然后是移除屏障消息，
并且判断是否需要唤醒消息队列继续取消息（唤醒next方法，这里的nativeWake用于唤醒，next方法中的nativePollOnce用于阻塞）。
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 (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.");
        }
         
        // 移除屏障消息，并判断是否需要唤醒队列（nativePollOnce用于阻塞，nativeWake用于唤醒）
        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);
        }
    }
}

参考：

1. https://www.cnblogs.com/renhui/p/12875589.html
2. https://mp.weixin.qq.com/s/CNpnS6y2IYobzDa7rAjy1Q
3. 链接：https://juejin.cn/post/6844903910113705998