Android 怎么就不卡了呢之Choreographer
题外话android
时光如斯 人世无常 逼哥突然就被 全网封杀数组
难过 尚未去听过现场 老是感受如今很忙 来日方长 我这种短视动物怎么屑于把意外这种小几率东西归入考虑范围呢 如今和未来这两个选项悲观点彻底能翻译成但愿与永别缓存
封杀缘由未知 若是是由于XD 这个自媒体猖獗的时代 是个好时代 它把这个世界本有的模样赤裸裸矗在你跟前 容许你怀疑思考进步 也是个坏时代 公信力成了伪命题 把人类最后那点遮羞布撕个粉碎 打击相信人性是正直勇敢美丽的勇气 若是是由于ZF 嗯 爱我中华bash
前言
针对Android UI不流畅的问题，Google提出了Project Butter对Android的显示系统进行了重构。 此次重构的三个关键点异步
- VSynch 垂直同步
- Triple Buffer 三重缓存
- Choreographer 编舞者
这篇文章咱们主要聊一聊Choregrapher，后续的咱们写关于其余。async
choreographer
界面的显示大致会通过CPU的计算-> GPU合成栅格化->显示设备显示。咱们知道Android设备的刷新频率通常都是60HZ也就是一秒60次，若是一次绘制在约16毫喵内完成时没有问题的。可是一旦出现不协调的地方就会出问题以下图ide
- 第一个周期，cpu计算、GPU操做、显示设备显示没有问题。
- 第二个周期，显示上一个周期绘制准备好的图像；CPU计算是在周期将要结束的时候才开始计算
- 第三个周期，因为进入第二个周期的时候CPU动手计算晚点了，导致进入第三个周期的时候本应该显示的图像没有准备好，致使整个第三个周期内仍是显示上一个周期的图像，这样看上去会卡，掉帧！google工程师们管整个叫Jank延误军机。
这事不小啊，怎么解决呢？垂直同步 简单的说，就是让CPU计算别没有计划没有规律而是在每一个周期开始的时候开始计算，这样就有条不紊的有序进行了（以下图）。这个在android4.1及之后的版本中加入了Choreographer这个类，让咱们扒开看看他是怎么实现的。 （Choreographer 这个类的位置android.view.Choreographer） oop
1、入口
1.1 postCallbackDelayedInternal
ViewRoot的 doTravle()方法中有这样一行代码布局
mChoreographer.postCallback(
Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
复制代码
它的意思就是对整个View树发起测量布局绘制操做。关于ViewRootImpl的更多内容这里就很少介绍了。post
如下方法
- 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（）;(关于这个handler的这个操做详细信息逻辑，参照下面本文附录一 handler 分发message
这个message设置为了异步 （msg.setAsynchronous(true);）这意味这他有优先执行的权利，他是怎么被优先执行的呢？参照附录三 message的异步模式
综上，添加callback流程
2、执行
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，挨个执行。
3、小结
- Choreographer对外提供了postCallback等方法，最终他们内部都是经过调用postCallbackDelayedInternal（）实现这个方法主要会作两件事情
- 存储Action
- 请求垂直同步，垂直同步
- 垂直同步回调立马执行Action（CallBack/Runnable）。
- Action一个动做内容的类型多是
- CALLBACK_INPUT输入时间优先级最高
- CALLBACK_ANIMATION 动画的次之
- CALLBACK_TRAVERSAL UI绘制布局的再次之
- CALLBACK_COMMIT动画修正相关最后。
- 复习Hanlder机制，我认为他是Android系统跑起来的大引擎终点关注下，handler对message的分发执行，以及“异步模式”。
附
附2、关于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表示已经安排了下一帧那么就返回，不添乱！
附3、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;
}
...
复制代码
完，水平有限，各位不吝批评指正。
- 1. Mysql1067怎么就是解决不了呢？
- 2. 淘集集怎么就破产了呢？
- 3. 该死，怎么就被加速了呢？
- 4. 明明长得一样，怎么就不认识你了呢
- 5. IntelliJ IDEA 更新后，电脑卡炸了，该怎么优化呢？
- 6. 我就死磕安卓了，怎么了？
- 7. 子弹短信怎么就一夜爆火了呢？？
- 8. iOS底层原理02-怎么就内存对齐了呢
- 9. 怎么判断是显卡不行了还是CPU不行了？
- 10. hackinglab-脚本关4——怎么就是不弹出key呢？
- 更多相关文章...
- • 您已经学习了 XML DOM，现在该怎么办呢？ - XML DOM 教程
- • 您已经学习了 XSLT，现在该怎么办？ - XSLT 教程
- • SpringBoot中properties文件不能自动提示解决方法
- • 互联网组织的未来：剖析GitHub员工的任性之源
-
每一个你不满意的现在，都有一个你没有努力的曾经。