Choreographer 解析

一、概述

在 Logcat 中使用關(guān)鍵詞 Choreographer 進(jìn)行過(guò)濾，對(duì) App 做一些操作，一般能看到控制臺(tái)輸出這樣的日志

I/Choreographer: Skipped 55 frames!  The application may be doing too much work on its main thread.
I/Choreographer: Skipped 43 frames!  The application may be doing too much work on its main thread.

這是觀察 App 掉幀情況的一種手段
默認(rèn)只會(huì)打印掉幀 >=30 幀的信息，已 ROOT 的手機(jī)可以修改此條件

getprop debug.choreographer.skipwarning      //讀取
setprop debug.choreographer.skipwarning 5    //修改
setprop ctl.restart surfaceflinger; setprop ctl.restart zygote    //重啟

理解 Choreographer 工作過(guò)程，有助于分析代碼調(diào)用過(guò)程、進(jìn)行幀率統(tǒng)計(jì)、分析 Systrace

二、Choreographer

硬件每 16 毫秒產(chǎn)一個(gè) VSync 信號(hào)，App 要想實(shí)現(xiàn)垂直同步，就是要收到 VSync
只有調(diào)用 DisplayEventReceiver 的 nativeScheduleVsync 方法后，才能收到下一個(gè) VSync
請(qǐng)求 VSync（即調(diào)用 nativeScheduleVsync）只是單次有效，并不是一勞永逸
請(qǐng)求 VSync → 收到 VSync → 請(qǐng)求 VSync → 收到 VSync
如果沒(méi)有再次請(qǐng)求 VSync，則無(wú)法收到 VSync

我們將 Choreographer 工作過(guò)程分為 2 部分來(lái)分析：請(qǐng)求 VSync 和 收到 VSync

1、Choreographer 請(qǐng)求 VSync

1.1 ViewRootImpl

[ViewRootImpl.java→]

void scheduleTraversals() {
    ...
    mChoreographer.postCallback(
            Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
    ...
}

@Override
public void requestLayout() {
    if (!mHandlingLayoutInLayoutRequest) {
        checkThread();
        mLayoutRequested = true;
        scheduleTraversals();
    }
}

void invalidate() {
    mDirty.set(0, 0, mWidth, mHeight);
    if (!mWillDrawSoon) {
        scheduleTraversals();
    }
}

熟悉 View 繪制過(guò)程的話，應(yīng)該知道會(huì)一直遞歸向上到 ViewRootImpl 最終會(huì)調(diào)用到 scheduleTraversals()
在 ViewRootImpl 里也能找到

mChoreographer.postCallback(Choreographer.CALLBACK_INPUT, ...

mChoreographer.postCallback(Choreographer.CALLBACK_ANIMATION, ...

1.2 mChoreographer.postCallback

[Choreographer.java→]

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) {
    if (action == null) {
        throw new IllegalArgumentException("action must not be null");
    }
    if (callbackType < 0 || callbackType > CALLBACK_LAST) {
        throw new IllegalArgumentException("callbackType is invalid");
    }

    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].addCallbackLocked(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);
        }
    }
}

把任務(wù)都放在 mCallbackQueues[callbackType] 隊(duì)列中

1.3 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 {
            // mLastFrameTimeNanos 主要作用于當(dāng) USE_VSYNC = false 的時(shí)候，設(shè)置 doFrame 的時(shí)間
            final long nextFrameTime = Math.max(
                    mLastFrameTimeNanos / TimeUtils.NANOS_PER_MS + sFrameDelay, now);
            Message msg = mHandler.obtainMessage(MSG_DO_FRAME);
            msg.setAsynchronous(true);
            mHandler.sendMessageAtTime(msg, nextFrameTime);
        }
    }
}

USE_VSYNC 默認(rèn)是 true，也就是代表開(kāi)啟垂直同步

private static final boolean USE_VSYNC = SystemProperties.getBoolean(
        "debug.choreographer.vsync", true);

// 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.

這句注釋意思就是如果當(dāng)前是在主線程，則立即執(zhí)行 scheduleVsyncLocked()，如果不是主線程，則通過(guò) mHandler 發(fā)消息給主線程，最終也是執(zhí)行 scheduleVsyncLocked()

1.4 scheduleVsyncLocked

mDisplayEventReceiver = FrameDisplayEventReceiver(looper) 

private void scheduleVsyncLocked() {
    mDisplayEventReceiver.scheduleVsync();
}

class FrameDisplayEventReceiver extends DisplayEventReceiver implements Runnable

[DisplayEventReceiver→]

public void scheduleVsync() {
    if (mReceiverPtr == 0) {
        Log.w(TAG, "Attempted to schedule a vertical sync pulse but the display event "
                + "receiver has already been disposed.");
    } else {
        nativeScheduleVsync(mReceiverPtr);
    }
}

2、Choreographer 收到 VSync

2.1 dispatchVsync

Java 層接收 VSync 的入口是 dispatchVsync()，看注釋就知道是從 native 調(diào)用的

[DisplayEventReceiver.java→]

// Called from native code.
private void dispatchVsync(long timestampNanos, int builtInDisplayId, int frame) {
    onVsync(timestampNanos, builtInDisplayId, frame);
}

斷點(diǎn)下就很清晰了，顯然收到 VSync 時(shí)會(huì)往 UI Looper 中插入一個(gè) msg，所以 onVsync 也是在主線程執(zhí)行的

2.2 onVsync

[Choreographer.java→]

private final class FrameDisplayEventReceiver extends DisplayEventReceiver
        implements Runnable {
    ...
    private long mTimestampNanos;

    public FrameDisplayEventReceiver(Looper looper) {
        super(looper);
    }

    @Override
    public void onVsync(long timestampNanos, int builtInDisplayId, int frame) {
        ...
        mTimestampNanos = timestampNanos;
        Message msg = Message.obtain(mHandler, this);
        msg.setAsynchronous(true);
        mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);
    }

    @Override
    public void run() {
        ...
        doFrame(mTimestampNanos, mFrame);
    }
}

Message.obtain(mHandler, this) 所以 msg.callback 是 this，只要清楚 Handler 工作原理就知道最后會(huì)調(diào)用到 msg.callback.run()，也就是 FrameDisplayEventReceiver run()，進(jìn)入 doFrame()
關(guān)注 mTimestampNanos，它是來(lái)自 onVsync 的 timestampNanos 參數(shù)，代表產(chǎn)生 VSync 的時(shí)間

2.3 doFrame

void doFrame(long frameTimeNanos, int frame) {
    final long startNanos;
    synchronized (mLock) {
        ...
        long intendedFrameTimeNanos = frameTimeNanos;
        startNanos = System.nanoTime();
        final long jitterNanos = startNanos - frameTimeNanos;
        if (jitterNanos >= mFrameIntervalNanos) {
            final long skippedFrames = jitterNanos / mFrameIntervalNanos;
            if (skippedFrames >= SKIPPED_FRAME_WARNING_LIMIT) {
                // 在控制臺(tái)觀察的就是這句
                Log.i(TAG, "Skipped " + skippedFrames + " frames!  "
                        + "The application may be doing too much work on its main thread.");
            }
            final long lastFrameOffset = jitterNanos % mFrameIntervalNanos;
            // 修正 frameTimeNanos
            frameTimeNanos = startNanos - lastFrameOffset;
        }
        
        if (frameTimeNanos < mLastFrameTimeNanos) {
            // 請(qǐng)求 VSync
            scheduleVsyncLocked();
            return;
        }

        mFrameInfo.setVsync(intendedFrameTimeNanos, frameTimeNanos);
        mFrameScheduled = false;
        mLastFrameTimeNanos = frameTimeNanos;
    }

    try {
        ...
        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 {
        ...
    }
    ...
}

當(dāng)出現(xiàn)掉幀時(shí)，會(huì)對(duì) frameTimeNanos 進(jìn)行修正，修正到最后一次 VSync 的時(shí)間
當(dāng) frameTimeNanos < mLastFrameTimeNanos 時(shí)，請(qǐng)求 VSync 然后 return，相當(dāng)于忽略本次信號(hào)，等待下一個(gè)信號(hào)。但這個(gè)條件不太可能通過(guò)，反正這個(gè)條件通過(guò)就代表出現(xiàn)異常情況。

2.4 doCallbacks

void doCallbacks(int callbackType, long frameTimeNanos) {
    CallbackRecord callbacks;
    synchronized (mLock) {
        // We use "now" to determine when callbacks become due because it's possible
        // for earlier processing phases in a frame to post callbacks that should run
        // in a following phase, such as an input event that causes an animation to start.
        final long now = System.nanoTime();
        callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked(
                now / TimeUtils.NANOS_PER_MS);
        if (callbacks == null) {
            return;
        }
        mCallbacksRunning = true;

        // Update the frame time if necessary when committing the frame.
        // We only update the frame time if we are more than 2 frames late reaching
        // the commit phase.  This ensures that the frame time which is observed by the
        // callbacks will always increase from one frame to the next and never repeat.
        // We never want the next frame's starting frame time to end up being less than
        // or equal to the previous frame's commit frame time.  Keep in mind that the
        // next frame has most likely already been scheduled by now so we play it
        // safe by ensuring the commit time is always at least one frame behind.
        if (callbackType == Choreographer.CALLBACK_COMMIT) {
            final long jitterNanos = now - frameTimeNanos;
            Trace.traceCounter(Trace.TRACE_TAG_VIEW, "jitterNanos", (int) jitterNanos);
            if (jitterNanos >= 2 * mFrameIntervalNanos) {
                final long lastFrameOffset = jitterNanos % mFrameIntervalNanos
                        + mFrameIntervalNanos;
                if (DEBUG_JANK) {
                    Log.d(TAG, "Commit callback delayed by " + (jitterNanos * 0.000001f)
                            + " ms which is more than twice the frame interval of "
                            + (mFrameIntervalNanos * 0.000001f) + " ms!  "
                            + "Setting frame time to " + (lastFrameOffset * 0.000001f)
                            + " ms in the past.");
                    mDebugPrintNextFrameTimeDelta = true;
                }
                frameTimeNanos = now - lastFrameOffset;
                mLastFrameTimeNanos = frameTimeNanos;
            }
        }
    }
    try {
        Trace.traceBegin(Trace.TRACE_TAG_VIEW, CALLBACK_TRACE_TITLES[callbackType]);
        for (CallbackRecord c = callbacks; c != null; c = c.next) {
            if (DEBUG_FRAMES) {
                Log.d(TAG, "RunCallback: type=" + callbackType
                        + ", action=" + c.action + ", token=" + c.token
                        + ", latencyMillis=" + (SystemClock.uptimeMillis() - c.dueTime));
            }
            c.run(frameTimeNanos);
        }
    } finally {
        synchronized (mLock) {
            mCallbacksRunning = false;
            do {
                final CallbackRecord next = callbacks.next;
                recycleCallbackLocked(callbacks);
                callbacks = next;
            } while (callbacks != null);
        }
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
}

extractDueCallbacksLocked 是取出執(zhí)行時(shí)間在當(dāng)前時(shí)間之前的所有 CallbackRecord，callbacks 是一個(gè)鏈表，然后遍歷 callbacks 執(zhí)行 run 方法

public void run(long frameTimeNanos) {
    if (token == FRAME_CALLBACK_TOKEN) {
        ((FrameCallback)action).doFrame(frameTimeNanos);
    } else {
        ((Runnable)action).run();
    }
}

看到上面代碼中有 FrameCallback.doFrame，只要 postFrameCallback(FrameCallback)，下一次 Choreographer doFrame 時(shí)就會(huì)調(diào)用 FrameCallback.doFrame

下面的代碼可以實(shí)現(xiàn)監(jiān)聽(tīng)每一幀

Choreographer.getInstance().postFrameCallback(new Choreographer.FrameCallback() {
    @Override
    public void doFrame(long frameTimeNanos) {
        // do something
        Choreographer.getInstance().postFrameCallback(this);
    }
});

doCallbacks 最后一步是 CALLBACK_COMMIT，如果 doCallbacks 耗時(shí) >= 32 毫秒，就修正 frameTimeNanos

圖中 doCallbacks 從 frameTimeNanos2 開(kāi)始執(zhí)行，執(zhí)行到進(jìn)入 CALLBACK_COMMIT 時(shí)，判斷
now - frameTimeNanos >= 2 * mFrameIntervalNanos，于是把 frameTimeNanos 修正到倒數(shù)第二個(gè)信號(hào)時(shí)間

3、Choreographer 與 Looper

Choreographer 中涉及到 Looper 的有

  1. postCallback → scheduleFrameLocked，dueTime > now 時(shí)經(jīng)過(guò) Looper
  2. scheduleFrameLocked → scheduleVsyncLocked，非 UI 線程時(shí)經(jīng)過(guò) Looper
  3. 收到 VSync → dispatchVsync，必定經(jīng)過(guò) Looper
  4. onVsync → doFrame，必定經(jīng)過(guò) Looper

這些 msg isAsynchronous() == true

三、msg.setAsynchronous(true)

msg.isAsynchronous() == true 表示是一個(gè)異步消息
當(dāng)有 MessageQueue 設(shè)置 barrier 時(shí)，只有異步消息可以被處理，同步消息無(wú)法被處理，只有移除 barrier 后，同步消息才會(huì)被處理
如果沒(méi)有設(shè)置 barrier，異步消息與同步消息沒(méi)有區(qū)別

1、postSyncBarrier 和 removeSyncBarrier

如何設(shè)置 barrier 和 移除 barrier，在 ViewRootImpl 里就可以看到

[ViewRootImpl.java→]

void scheduleTraversals() {
    if (!mTraversalScheduled) {
        mTraversalScheduled = true;
        mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
        mChoreographer.postCallback(
                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
        ...
    }
}

void doTraversal() {
    if (mTraversalScheduled) {
        mTraversalScheduled = false;
        mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);
        ...
        performTraversals();
        ...
    }
}

2、example

寫(xiě)個(gè) example 看下 msg 的調(diào)用順序就知道 barrier 和異步消息是如何使用的

private Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        Log.d("TEST", "" + msg.what);
        if (msg.what == 3) {
            removeSyncBarrier(mHandler, mBarrier);
            mBarrier = -1;
        }

    }
};

private int mBarrier = -1;

@Override
public void onClick(View v) {
    mBarrier = postSyncBarrier(mHandler);
    //------------------------------------------------------------
    mHandler.post(new Runnable() {
        @Override
        public void run() {
            Log.d("TEST", "1");

        }
    });
    //------------------------------------------------------------
    Message msg = Message.obtain(mHandler, new Runnable() {
        @Override
        public void run() {
            Log.d("TEST", "2");
        }
    });
    mHandler.sendMessageDelayed(msg, 1000);
    //------------------------------------------------------------
    Message msg3 = Message.obtain();
    msg3.setAsynchronous(true);
    msg3.what = 3;
    mHandler.sendMessageDelayed(msg3, 2000);
    //------------------------------------------------------------
    Message msg4 = Message.obtain();
    msg4.setAsynchronous(true);
    msg4.what = 4;
    mHandler.sendMessageDelayed(msg4, 1500);
    //------------------------------------------------------------
    Message msg5 = Message.obtain();
    msg5.what = 5;
    mHandler.sendMessage(msg5);
}

public static int postSyncBarrier(Handler handler) {
    MessageQueue messageQueue = handler.getLooper().getQueue();
    try {
        Method postSyncBarrier = messageQueue.getClass().getDeclaredMethod("postSyncBarrier");
        postSyncBarrier.setAccessible(true);
        return (int) postSyncBarrier.invoke(messageQueue);
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
    return -1;
}

public static void removeSyncBarrier(Handler handler, int barrier) {
    MessageQueue messageQueue = handler.getLooper().getQueue();
    try {
        Method removeSyncBarrier = messageQueue.getClass().getDeclaredMethod("removeSyncBarrier", int.class);
        removeSyncBarrier.setAccessible(true);
        removeSyncBarrier.invoke(messageQueue, barrier);
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
}

輸出順序是 4 3 1 5 2

3、scheduleTraversals 和 doTraversal

  1. scheduleTraversals
  2. postSyncBarrier
  3. mChoreographer.postCallback
  4. Choreographer ... → doCallback
  5. mTraversalRunnable.run → doTraversal
  6. removeSyncBarrier

這整個(gè)過(guò)程只有異步消息可以被處理，Choreographer 過(guò)程中的動(dòng)作也都是異步消息，這樣可以確保 Choreographer 的順利運(yùn)轉(zhuǎn)，也確保了第一時(shí)間執(zhí)行 doTraversal（doTraversal → performTraversals 就是執(zhí)行 view 的 layout、measure、draw），這個(gè)過(guò)程中如果有其他同步消息，也無(wú)法得到處理，都要等到 doTraversal 之后

下面這 2 行代碼就沒(méi)有 postSyncBarrier，顯然沒(méi)有 View 繪制的優(yōu)先級(jí)高

[ViewRootImpl.java→]

mChoreographer.postCallback(Choreographer.CALLBACK_INPUT, ...

mChoreographer.postCallback(Choreographer.CALLBACK_ANIMATION, ...

四、舉例分析

以下圖為例，分析執(zhí)行過(guò)程

  1. postCallback(runnable1) → scheduleFrameLocked() → scheduleVsync()
  2. frameTimeNanos1 時(shí)刻收到 VSync，往 Looper 隊(duì)列插入一個(gè) msg
  3. Looper 取出 2 的 msg，調(diào)用 onVsync(frameTimeNanos1) → doFrame(frameTimeNanos1)
    ??3.1) 判斷沒(méi)有掉幀
    ??3.2) doCallbacks 調(diào)用 runnable1.run()
  4. postCallback(runnable1) → scheduleFrameLocked() → scheduleVsync()
  5. postCallback(runnable3)
    scheduleFrameLocked() 判斷 mFrameScheduled == true 直接 return，所以并不會(huì)調(diào)用 scheduleVsync()
  6. frameTimeNanos2 時(shí)刻收到 VSync，往 Looper 隊(duì)列插入一個(gè) msg
  7. Looper 取出 6 的 msg，調(diào)用 onVsync(frameTimeNanos2) → doFrame(frameTimeNanos2)
    7.1 雖然有延遲，但是延遲沒(méi)有超過(guò) 16 毫秒，判斷沒(méi)有掉幀
    7.2 doCallbacks 調(diào)用 runnable2.run() 和 runnable3.run()
  8. 非 UI 線程 postCallback(runnable4) 往 Looper 隊(duì)列插入一個(gè) msg
  9. frameTimeNanos3 時(shí)刻接收不到 VSync，因?yàn)樽陨洗问盏?VSync 后，未調(diào)用過(guò) scheduleVsync()
  10. Looper 取出 8 的 msg，調(diào)用 scheduleFrameLocked → scheduleVsync()
  11. frameTimeNanos4 時(shí)刻收到 VSync，往 Looper 隊(duì)列插入一個(gè) msg
  12. Looper 取出 11 的 msg，調(diào)用 onVsync(frameTimeNanos4) → doFrame(frameTimeNanos4)
    12.1 延遲超過(guò) 16 毫秒，判斷掉幀
    12.2 修正 frameTimeNanos，frameTimeNanos = frameTimeNanos5
    12.3 doCallbacks 調(diào)用 runnable4.run()
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請(qǐng)結(jié)合常識(shí)與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書(shū)系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容