一、概述
在 Logcat 中使用關鍵詞 Choreographer 進行過濾，對 App 做一些操作，一般能看到控制臺輸出這樣的日志
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 掉幀情況的一種手段
默認只會打印掉幀 >=30 幀的信息，已 ROOT 的手機可以修改此條件
getprop debug.choreographer.skipwarning //讀取
setprop debug.choreographer.skipwarning 5 //修改
setprop ctl.restart surfaceflinger; setprop ctl.restart zygote //重啟
理解 Choreographer 工作過程，有助于分析代碼調用過程、進行幀率統計、分析 Systrace
二、Choreographer
硬件每 16 毫秒產一個 VSync 信號，App 要想實現垂直同步，就是要收到 VSync
只有調用 DisplayEventReceiver 的 nativeScheduleVsync 方法后，才能收到下一個 VSync
請求 VSync（即調用 nativeScheduleVsync）只是單次有效，并不是一勞永逸
請求 VSync → 收到 VSync → 請求 VSync → 收到 VSync
如果沒有再次請求 VSync，則無法收到 VSync
我們將 Choreographer 工作過程分為 2 部分來分析：請求 VSync 和 收到 VSync
1、Choreographer 請求 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 繪制過程的話，應該知道會一直遞歸向上到 ViewRootImpl 最終會調用到 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);
}
}
}
把任務都放在 mCallbackQueues[callbackType] 隊列中
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 主要作用于當 USE_VSYNC = false 的時候，設置 doFrame 的時間
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 默認是 true，也就是代表開啟垂直同步
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.
這句注釋意思就是如果當前是在主線程，則立即執行 scheduleVsyncLocked()，如果不是主線程，則通過 mHandler 發消息給主線程，最終也是執行 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 調用的
[DisplayEventReceiver.java→]
// Called from native code.
private void dispatchVsync(long timestampNanos, int builtInDisplayId, int frame) {
onVsync(timestampNanos, builtInDisplayId, frame);
}
斷點下就很清晰了，顯然收到 VSync 時會往 UI Looper 中插入一個 msg，所以 onVsync 也是在主線程執行的
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 工作原理就知道最后會調用到 msg.callback.run()，也就是 FrameDisplayEventReceiver run()，進入 doFrame()
關注 mTimestampNanos，它是來自 onVsync 的 timestampNanos 參數，代表產生 VSync 的時間
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) {
// 在控制臺觀察的就是這句
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) {
// 請求 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 {
...
}
...
}
當出現掉幀時，會對 frameTimeNanos 進行修正，修正到最后一次 VSync 的時間
當 frameTimeNanos < mLastFrameTimeNanos 時，請求 VSync 然后 return，相當于忽略本次信號，等待下一個信號。但這個條件不太可能通過，反正這個條件通過就代表出現異常情況。
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 是取出執行時間在當前時間之前的所有 CallbackRecord，callbacks 是一個鏈表，然后遍歷 callbacks 執行 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 時就會調用 FrameCallback.doFrame
下面的代碼可以實現監聽每一幀
Choreographer.getInstance().postFrameCallback(new Choreographer.FrameCallback() {
@Override
public void doFrame(long frameTimeNanos) {
// do something
Choreographer.getInstance().postFrameCallback(this);
}
});
doCallbacks 最后一步是 CALLBACK_COMMIT，如果 doCallbacks 耗時 >= 32 毫秒，就修正 frameTimeNanos
圖中 doCallbacks 從 frameTimeNanos2 開始執行，執行到進入 CALLBACK_COMMIT 時，判斷
now - frameTimeNanos >= 2 * mFrameIntervalNanos，于是把 frameTimeNanos 修正到倒數第二個信號時間
3、Choreographer 與 Looper
Choreographer 中涉及到 Looper 的有
- postCallback → scheduleFrameLocked，dueTime > now 時經過 Looper
- scheduleFrameLocked → scheduleVsyncLocked，非 UI 線程時經過 Looper
- 收到 VSync → dispatchVsync，必定經過 Looper
- onVsync → doFrame，必定經過 Looper
這些 msg isAsynchronous() == true
三、msg.setAsynchronous(true)
msg.isAsynchronous() == true 表示是一個異步消息
當有 MessageQueue 設置 barrier 時，只有異步消息可以被處理，同步消息無法被處理，只有移除 barrier 后，同步消息才會被處理
如果沒有設置 barrier，異步消息與同步消息沒有區別
1、postSyncBarrier 和 removeSyncBarrier
如何設置 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
寫個 example 看下 msg 的調用順序就知道 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
- scheduleTraversals
- postSyncBarrier
- mChoreographer.postCallback
- Choreographer ... → doCallback
- mTraversalRunnable.run → doTraversal
- removeSyncBarrier
這整個過程只有異步消息可以被處理，Choreographer 過程中的動作也都是異步消息，這樣可以確保 Choreographer 的順利運轉，也確保了第一時間執行 doTraversal（doTraversal → performTraversals 就是執行 view 的 layout、measure、draw），這個過程中如果有其他同步消息，也無法得到處理，都要等到 doTraversal 之后
下面這 2 行代碼就沒有 postSyncBarrier，顯然沒有 View 繪制的優先級高
[ViewRootImpl.java→]
mChoreographer.postCallback(Choreographer.CALLBACK_INPUT, ...
mChoreographer.postCallback(Choreographer.CALLBACK_ANIMATION, ...
四、舉例分析
以下圖為例，分析執行過程
- postCallback(runnable1) → scheduleFrameLocked() → scheduleVsync()
- frameTimeNanos1 時刻收到 VSync，往 Looper 隊列插入一個 msg
- Looper 取出 2 的 msg，調用 onVsync(frameTimeNanos1) → doFrame(frameTimeNanos1)
??3.1) 判斷沒有掉幀
??3.2) doCallbacks 調用 runnable1.run() - postCallback(runnable1) → scheduleFrameLocked() → scheduleVsync()
- postCallback(runnable3)
scheduleFrameLocked() 判斷 mFrameScheduled == true 直接 return，所以并不會調用 scheduleVsync() - frameTimeNanos2 時刻收到 VSync，往 Looper 隊列插入一個 msg
- Looper 取出 6 的 msg，調用 onVsync(frameTimeNanos2) → doFrame(frameTimeNanos2)
7.1 雖然有延遲，但是延遲沒有超過 16 毫秒，判斷沒有掉幀
7.2 doCallbacks 調用 runnable2.run() 和 runnable3.run() - 非 UI 線程 postCallback(runnable4) 往 Looper 隊列插入一個 msg
- frameTimeNanos3 時刻接收不到 VSync，因為自上次收到 VSync 后，未調用過 scheduleVsync()
- Looper 取出 8 的 msg，調用 scheduleFrameLocked → scheduleVsync()
- frameTimeNanos4 時刻收到 VSync，往 Looper 隊列插入一個 msg
- Looper 取出 11 的 msg，調用 onVsync(frameTimeNanos4) → doFrame(frameTimeNanos4)
12.1 延遲超過 16 毫秒，判斷掉幀
12.2 修正 frameTimeNanos，frameTimeNanos = frameTimeNanos5
12.3 doCallbacks 調用 runnable4.run()
