Android 怎么就不卡了呢之Choreographer

最新推荐文章于 2024-11-02 10:50:29 发布

OpenHarmony_小贾

最新推荐文章于 2024-11-02 10:50:29 发布

阅读量207

点赞数

分类专栏： Android 移动开发性能优化文章标签： android Framework 移动开发 binder 面试

本文链接：https://blog.csdn.net/maniuT/article/details/132103951

版权

移动开发同时被 3 个专栏收录

955 篇文章 13 订阅

订阅专栏

Android

226 篇文章 8 订阅

订阅专栏

性能优化

58 篇文章 2 订阅

订阅专栏

作者：花海blog

前言

针对Android UI不流畅的问题，Google提出了Project Butter对Android的显示系统进行了重构。这次重构的三个关键点

VSynch 垂直同步
Triple Buffer 三重缓存
Choreographer 编舞者

这篇文章我们主要聊一聊Choregrapher，后续的我们写关于其他。

choreographer

界面的显示大体会经过CPU的计算-> GPU 合成栅格化->显示设备显示。我们知道Android设备的刷新频率一般都是60HZ也就是一秒60次，如果一次绘制在约16毫喵内完成时没有问题的。但是一旦出现不协调的地方就会出问题如下图

第一个周期内cpu计算、GPU操作、显示设备显示没有问题
第二周期内，显示上一个周期绘制准备好的图像，没有问题。CPU计算是在周期将要结束的时候才开始计算
第三个周期，由于进入第第二个周期的时候CPU动手计算晚点了导致后续，进入第三个周期的时候本应该显示的图像没有准备好，导致整个第三个个周期内还是显示上一个周期的图像，这样看上去会卡，掉帧！google工程师们管整个叫Jank延误军机。

这事不小啊，怎么解决呢？垂直同步简单的说，就是让CPU计算别没有计划没有规律而是在每个周期开始的时候开始计算，紧接着这样就有条不紊的有序进行了（如下图）。这个在android4.1及以后的版本中加入了Choreographer这个类，让我们扒开看看他是怎么实现的。

一、入口

1.1 postCallbackDelayedInternal

ViewRoot的 doTravle()方法中有这样一行代码

mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);

它的意思就是对整个View树发起测量布局绘制操作。关于ViewRootImpl的更多内容这里就不多介绍了。

以下方法

public void postCallback(…) ;
public void postCallbackDelayed(…);
public void postFrameCallback(FrameCallback callback);
public void postFrameCallbackDelayed(FrameCallback callback, long delayMillis)

最终都会调用 postCallbackDelayedInternal();，那么我们就看看这个方法的功能。

   private void postCallbackDelayedInternal(int callbackType,
                                             Object action, Object token, long delayMillis) {
        synchronized (mLock) {
            final long now = SystemClock.uptimeMillis();//获取当前时间
            final long dueTime = now + delayMillis;//到期时间
            //将执行动作放在mCallback数组中
            mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);
            //如果已经到期就注册请求垂直同步信号
            if (dueTime <= now) {
                scheduleFrameLocked(now);
            } else {
            //如果还没有到期，使用handler在发送一个延时消息。这个延时消息会在到期的时候执行。
                Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
                msg.arg1 = callbackType;
                msg.setAsynchronous(true);
                mHandler.sendMessageAtTime(msg, dueTime);
            }
        }
    }

1.2 FrameHandler

上一小节，如果已经到期就直接执行scheduleFrameLocked（）方法，如果没有执行就使用mHandler（FrameHandler类型）发送一个what值为MSG_DO_SCHEDULE_CALLBACK的Message。到期后怎么执行的呢。这要看FrameHandler怎么处理的。

 private final class FrameHandler extends Handler {
        public FrameHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_DO_FRAME:
                    doFrame(System.nanoTime(), 0);
                    break;
                case MSG_DO_SCHEDULE_VSYNC:
                    doScheduleVsync();
                    break;
                case MSG_DO_SCHEDULE_CALLBACK:
                //postCallbackDelayedInternal（）方法中当未到期的时候发送过来的
                    doScheduleCallback(msg.arg1);
                    break;
            }
        }
    }

以上代码我们可以看出这个，FramHandler拿到 whate属性值为MSG_DO_SCHEDULE_CALLBACK的时候会去执行 doScheduleCallback(msg.arg1);方法，跟进去看下

1.3 Choreography#doScheduleCallback

void doScheduleCallback(int callbackType) {
        synchronized (mLock) {
            if (!mFrameScheduled) {
                final long now = SystemClock.uptimeMillis();
                if (mCallbackQueues[callbackType].hasDueCallbacksLocked(now)) {
                    scheduleFrameLocked(now);
                }
            }
        }
    }

这个方法中先是做了一些判断，mFrameSceduled为false 并且hasDueCallbacksLocked（）这个方法的返回值为true，看方法名就能猜出这个callback是否到期了，下面我们再分析这个。最终如果满足条件的情况下它会调用 scheduleFrameLocked()这个方法，咦这个方法眼熟不？对，没错，postCallbackDelayedInternal（）方法中如果到期了的话就直接执行的那个方法。是时候看这个方法里面搞的什么事情了。

1.4 scheduleFrameLocked（）

    private void scheduleFrameLocked(long now) {
        if (!mFrameScheduled) {
            mFrameScheduled = true;//设置标记位，表示已经安排请求下一帧渲染了。
            if (USE_VSYNC) {

                // If running on the Looper thread, then schedule the vsync immediately,
                // otherwise post a message to schedule the vsync from the UI thread
                // as soon as possible.
                /**
                翻译一下，如果在主线程中，就直接调用立即安排垂直同步，否则也就是非主线程的化就发送一个消息在主线程尽快安排一个垂直同步
                */
                if (isRunningOnLooperThreadLocked()) {
                    scheduleVsyncLocked();
                } else {
                    Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);
                    msg.setAsynchronous(true);
                    mHandler.sendMessageAtFrontOfQueue(msg);
                }
            } else {
                final long nextFrameTime = Math.max(
                        mLastFrameTimeNanos / TimeUtils.NANOS_PER_MS + sFrameDelay, now);
                if (DEBUG_FRAMES) {
                    Log.d(TAG, "Scheduling next frame in " + (nextFrameTime - now) + " ms.");
                }
                Message msg = mHandler.obtainMessage(MSG_DO_FRAME);
                msg.setAsynchronous(true);
                mHandler.sendMessageAtTime(msg, nextFrameTime);
            }
        }
    }

这个方法的目的很明确就是安排，安排垂直同步而且立刻马上尽快。安排垂直同步的条件是USE_VSYNC为true，也就是设备支持垂直同步
如果不是垂直同步就通过handler发送一个延时一个周期的消息安排垂直同步，这个Message的what值为 MSG_DO_FRAME，参照1.2的代码块对what为MSG_DO_FRAME的消息会去执行doFrame（）方法。
一个细节,当这个值mFrameScheduled为true的时候就直接返回不安排请求下一帧渲染了，如果为false，执行scheduleFrameLocked（）方法继续执行，并且将其设置为ture；在什么时候设置为false的呢？

安排垂直同步的具体实现是FrameDisplayEventReceiver类他是DisplayEventReceiver的用于接收垂直信号

    private final class FrameDisplayEventReceiver extends DisplayEventReceiver
            implements Runnable {
        private boolean mHavePendingVsync;
        private long mTimestampNanos;
        private int mFrame;

        public FrameDisplayEventReceiver(Looper looper, int vsyncSource) {
            super(looper, vsyncSource);
        }
        @Override
        public void onVsync(long timestampNanos, int builtInDisplayId, int frame) {
            mTimestampNanos = timestampNanos;
            mFrame = frame;
            Message msg = Message.obtain(mHandler, this);
            msg.setAsynchronous(true);//Message设置为异步
            mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);
        }
        @Override
        public void run() {
            mHavePendingVsync = false;
            doFrame(mTimestampNanos, mFrame);
        }
    }

接收到垂直同步信号后回调onVsync方法，这个方法使用handler发送带callback（Runnable类型，自身已继承）的message，最后run（）中也是调用doFrame（）;

这个message设置为了异步（msg.setAsynchronous(true);）这意味这他有优先执行的权利，他是怎么被优先执行的呢？

综上，添加callback流程

二、执行

doFrame

    void doFrame(long frameTimeNanos, int frame) {
        final long startNanos;
        synchronized (mLock) {
            if (!mFrameScheduled) {
                return; // no work to do
            }

            //当前时间
            startNanos = System.nanoTime();
            //当前时间和垂直同步时间
            final long jitterNanos = startNanos - frameTimeNanos;
            //垂直同步时间和当前时间的差值如果大于一个周期就修正一下
            if (jitterNanos >= mFrameIntervalNanos) {
            //取插值和始终周期的余数
               final long lastFrameOffset = jitterNanos % mFrameIntervalNanos;
               //当前时间减去上一步得到的余数当作最新的始终信号时间
               frameTimeNanos = startNanos - lastFrameOffset;
            }
            //垂直同步时间上一次时间还小，就安排下次垂直，直接返回
            if (frameTimeNanos < mLastFrameTimeNanos) {
                scheduleVsyncLocked();
                return;
            }
            mFrameInfo.setVsync(intendedFrameTimeNanos, frameTimeNanos);
            mFrameScheduled = false;
            mLastFrameTimeNanos = frameTimeNanos;
        }

        try {
            Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Choreographer#doFrame");
            AnimationUtils.lockAnimationClock(frameTimeNanos / TimeUtils.NANOS_PER_MS);

            mFrameInfo.markInputHandlingStart();
            doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos);

            mFrameInfo.markAnimationsStart();
            doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos);

            mFrameInfo.markPerformTraversalsStart();
            doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos);

            doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos);
        } finally {
            AnimationUtils.unlockAnimationClock();
            Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        }

        if (DEBUG_FRAMES) {
            final long endNanos = System.nanoTime();
            Log.d(TAG, "Frame " + frame + ": Finished, took "
                    + (endNanos - startNanos) * 0.000001f + " ms, latency "
                    + (startNanos - frameTimeNanos) * 0.000001f + " ms.");
        }
    }

第一步修正判断

当前时间 startNanos = System.nanoTime();
求当前时间和垂直同步时间的差值：jitterNanos = startNanos - frameTimeNanos;
垂直同步时间和当前时间的差值如果大于一个周期（jitterNanos >= mFrameIntervalNanos）就修正一下
- 取插值和始终周期的余数：lastFrameOffset = jitterNanos % mFrameIntervalNanos;
- 当前时间减去上一步得到的余数当作最新的始终信号时间：frameTimeNanos = startNanos - lastFrameOffset;
垂直同步时间上一次时间还小，就安排下次渲染： frameTimeNanos < mLastFrameTimeNanos，直接返回

第二步‍执行callback callback的执行顺序是：

CALLBACK_INPUT输入时间优先级最高
CALLBACK_ANIMATION 动画的次之
CALLBACK_TRAVERSAL UI绘制布局的再次之
CALLBACK_COMMIT动画修正相关最后。

2.2 doCallbacks();

在 CallbackQueue[] mCallbackQueues在取特定类型（输入，动画，布局，Commit）的单向链表
然后取出已到期的Callback/Runable执行

取出需要被执行的Actions

Action包装在CallbackRecord中，是一个单向列表，按照时间的大小顺序排列的。取出待执行的Actions是通过CallBackQueue的extractDueCallbacksLocked（）方法，可以把CallBackQueue看做是CallBack的管理类，其中还包括添加Action addCallbackLocked（），移除Action removeCallbacksLocked（）,是否有带起的Anction hasDueCallbacksLocked（）方法。

 private final class CallbackQueue {
        //链表头
        private CallbackRecord mHead;
        //是否存在已经到期的Action
        public boolean hasDueCallbacksLocked(long now) {
            return mHead != null && mHead.dueTime <= now;
        }
        //获取已经到期的Action
        public CallbackRecord extractDueCallbacksLocked(long now) {
            ...
            return callbacks;
        }

        //添加Action
        public void addCallbackLocked(long dueTime, Object action, Object token) {
         ...
        }
        //移除Action
        public void removeCallbacksLocked(Object action, Object token) {
          ...
        }
    }

执行Action

   for (CallbackRecord c = callbacks; c != null; c = c.next) {
                c.run(frameTimeNanos);
    }

从callback中遍历出CallBcakRecord，挨个执行。

三、小结

Choreographer对外提供了postCallback等方法，最终他们内部都是通过调用postCallbackDelayedInternal（）实现这个方法主要会做两件事情
- 存储Action
- 请求垂直同步，垂直同步
垂直同步回调立马执行Action（CallBack/Runnable）。
Action一个动作内容的类型可能是
- CALLBACK_INPUT输入时间优先级最高
- CALLBACK_ANIMATION 动画的次之
- CALLBACK_TRAVERSAL UI绘制布局的再次之
- CALLBACK_COMMIT动画修正相关最后。
复习Hanlder机制，我认为他是Android系统跑起来的大引擎终点关注下，handler对message的分发执行，以及“异步模式”。

附

附一、关于handler执行Message

下面是handler分发逻辑，Looper在MessageQueue得到要执行的message之后就会交给message的target（Handler类型）属性处理msg.target.dispatchMessage(msg);;

    public void dispatchMessage(Message msg) {
    //当msg的callback不为空的时候直接执行msg的callback它是一个Runnable对象
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
    //然后再交给mCallBack，它是handler的一个属性， 
    //创建Handler的时候可以选择传入一个CallBack对象
    //当callBack中handleMessage返回true的时候表示：True if no further handling is desired（不需要进一步处理）

            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
    //当mCallback处理返回为false的时候才去执行Handler自身的handleMessage（）方法
            handleMessage(msg);
        }
    }

关键逻辑在已注释，小结一下 handler的执行分发Message逻辑

如果message的callback（runnable）属性不为空，调用这个runable的run（）方法执行

 private static void handleCallback(Message message) {
        message.callback.run();
    }

当我们使用handler.post(Runnable r)方法时候就是将r设置给message的callback

上述条件不满足的情况下，如果handler自身的mCallback不为空的时候就会，将message交给mCallback处理，handlerMessage（）结束。这个属性是在handler创建的时候传入的。mCallback是CallBack类型，他是handler的一个内部接口。

    public interface Callback {
         boolean handleMessage(Message msg);
    }

3.当messaga 的callBak为空，且handler的mCallBack为空的时候就交给自己的handlerMessage（）方法执行了。我们在自定义handler的时候可以重写这个方法对message进行相应的操作。

附二、mFrameScheduled属性作用

执行callcack的时候会判断mFrameScheduled属性如果为false表示没有安排渲染下一帧就直接返回，不执行。

  void doFrame(long frameTimeNanos, int frame) {
        final long startNanos;
        synchronized (mLock) {
            if (!mFrameScheduled) {
                return; // no work to do
            }
            ...
            ...
            mFrameScheduled = false;
           ...
        }

在scheduleFrameLocked()方法中，将mFrameScheduled值设置为ture表示安排了请求渲染下一帧。如果这时mFrameScheduled为true表示已经安排了下一帧那么就返回，不添乱！

附三、Handler机制的异步模式

作用

“异步模式”的作用就是优先，asynchronous 的message在异步模式下有优先执行的权。

用法

MessageQueue使用postSyncBarrier（）方法添加屏障，removeSyncBarrier（）方法移除屏障这个两个方法是成对使用的。

实现原理

messageQueued的postSyncBarrier方法向messagequeue的头部添加一个target属性为null的message
messageQueue的next（）当碰到target为null的message的时候就只会在message链表中取出去“异步message”,而忽略普通的message，交给Looper做进一步分发处理。

 Message next() {
   ...
   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) {
               // Stalled by a barrier.  Find the next asynchronous messagin the queue.
               do {
                   prevMsg = msg;
                   msg = msg.next;
               } while (msg != null && !msg.isAsynchronous());
           }                       ...
           return msg;
         }
  ...