Vsync信号机制和UI刷新流程

[[439732]]

 

前言

屏幕刷新帧率不稳定，掉帧严重，无法保证每秒60帧，导致屏幕画面撕裂;

今天我们来讲解下Vsync机制和UI刷新流程

一、 Vsync信号详解

1、屏幕刷新相关知识点

  • 屏幕刷新频率：一秒内屏幕刷新的次数(一秒内显示了多少帧的图像)，单位 Hz(赫兹)，如常见的 60 Hz。刷新频率取决于硬件的固定参数(不会变的);
  • 逐行扫：显示器并不是一次性将画面显示到屏幕上，而是从左到右边，从上到下逐行扫描，顺序显示整屏的一个个像素点，不过这一过程快到人眼无法察觉到变化。以 60 Hz 刷新率的屏幕为例，这一过程即 1000 / 60 ≈ 16ms;
  • 帧率：表示 GPU 在一秒内绘制操作的帧数，单位 fps。例如在电影界采用 24 帧的速度足够使画面运行的非常流畅。而 Android 系统则采用更加流程的 60 fps，即每秒钟GPU最多绘制 60 帧画面。帧率是动态变化的，例如当画面静止时，GPU 是没有绘制操作的，屏幕刷新的还是buffer中的数据，即GPU最后操作的帧数据;
  • 屏幕流畅度：即以每秒60帧(每帧16.6ms)的速度运行，也就是60fps，并且没有任何延迟或者掉帧;
  • FPS：每秒的帧数;
  • 丢帧：在16.6ms完成工作却因各种原因没做完，占了后n个16.6ms的时间，相当于丢了n帧;

2、VSYNC机制

VSync机制：Android系统每隔16ms发出VSYNC信号，触发对UI进行渲染，VSync是Vertical Synchronization(垂直同步)的缩写，是一种在PC上很早就广泛使用的技术，可以简单的把它认为是一种定时中断。而在Android 4.1(JB)中已经开始引入VSync机制;

VSync机制下的绘制过程;CPU/GPU接收vsync信号，Vsync每16ms一次，那么在每次发出Vsync命令时，CPU都会进行刷新的操作。也就是在每个16ms的第一时间，CPU就会响应Vsync的命令，来进行数据刷新的动作。CPU和GPU的刷新时间，和Display的FPS是一致的。因为只有到发出Vsync命令的时候，CPU和GPU才会进行刷新或显示的动作。CPU/GPU接收vsync信号提前准备下一帧要显示的内容，所以能够及时准备好每一帧的数据，保证画面的流畅;

可见vsync信号没有提醒CPU/GPU工作的情况下，在第一个16ms之内，一切正常。然而在第二个16ms之内，几乎是在时间段的最后CPU才计算出了数据，交给了Graphics Driver,导致GPU也是在第二段的末尾时间才进行了绘制，整个动作延后到了第三段内。从而影响了下一个画面的绘制。这时会出现Jank(闪烁，可以理解为卡顿或者停顿)。这时候CPU和GPU可能被其他操作占用了，这就是卡顿出现的原因;

二、UI刷新原理流程

1、VSYNC流程示意

当我们通过setText改变TextView内容后，UI界面不会立刻改变，APP端会先向VSYNC服务请求，等到下一次VSYNC信号触发后，APP端的UI才真的开始刷新，基本流程如下：

setText最终调用invalidate申请重绘，最后会通过ViewParent递归到ViewRootImpl的invalidate，请求VSYNC，在请求VSYNC的时候，会添加一个同步栅栏，防止UI线程中同步消息执行，这样做为了加快VSYNC的响应速度，如果不设置，VSYNC到来的时候，正在执行一个同步消息;

2、view的invalidate

View会递归的调用父容器的invalidateChild，逐级回溯，最终走到ViewRootImpl的invalidate

 
 
 
 
    
  
  
  
  
  1. View.java 
    2. 
  
  
  
  
  2.  void invalidateInternal(int l, int t, int r, int b, boolean invalidateCache, 
    3. 
  
  
  
  
  3.             boolean fullInvalidate) { 
    4. 
  
  
  
  
  4.             // Propagate the damage rectangle to the parent view. 
    5. 
  
  
  
  
  5.             final AttachInfo ai = mAttachInfo; 
    6. 
  
  
  
  
  6.             final ViewParent p = mParent; 
    7. 
  
  
  
  
  7.             if (p != null && ai != null && l < r && t < b) { 
    8. 
  
  
  
  
  8.                 final Rect damage = ai.mTmpInvalRect; 
    9. 
  
  
  
  
  9.                 damage.set(l, t, r, b); 
    10. 
  
  
  
  
  10.                 p.invalidateChild(this, damage); 
    11. 
  
  
  
  
  11.             } 
    12. 
  
  
  
  
  12. ViewRootImpl.java 
    13. 
  
  
  
  
  13. void invalidate() { 
    14. 
  
  
  
  
  14.     mDirty.set(0, 0, mWidth, mHeight); 
    15. 
  
  
  
  
  15.     if (!mWillDrawSoon) { 
    16. 
  
  
  
  
  16.         scheduleTraversals(); 
    17. 
  
  
  
  
  17.     } 
    18. 
  
  
  
  
  18. } 
    19.

ViewRootImpl会调用scheduleTraversals准备重绘，但是，重绘一般不会立即执行，而是往Choreographer的Choreographer.CALLBACK_TRAVERSAL队列中添加了一个mTraversalRunnable，同时申请VSYNC，这个mTraversalRunnable要一直等到申请的VSYNC到来后才会被执行;

3、scheduleTraversals

 
 
 
 
    
  
  
  
  
  1. ViewRootImpl.java 
    2. 
  
  
  
  
  2.  // 将UI绘制的mTraversalRunnable加入到下次垂直同步信号到来的等待callback中去 
    3. 
  
  
  
  
  3.  // mTraversalScheduled用来保证本次Traversals未执行前，不会要求遍历两边，浪费16ms内，不需要绘制两次 
    4. 
  
  
  
  
  4. void scheduleTraversals() { 
    5. 
  
  
  
  
  5.     if (!mTraversalScheduled) { 
    6. 
  
  
  
  
  6.         mTraversalScheduled = true; 
    7. 
  
  
  
  
  7.         // 防止同步栅栏，同步栅栏的意思就是拦截同步消息 
    8. 
  
  
  
  
  8.         mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier(); 
    9. 
  
  
  
  
  9.         // postCallback的时候，顺便请求vnsc垂直同步信号scheduleVsyncLocked 
    10. 
  
  
  
  
  10.         mChoreographer.postCallback( 
    11. 
  
  
  
  
  11.                 Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null); 
    12. 
  
  
  
  
  12.           
    13. 
  
  
  
  
  13.         if (!mUnbufferedInputDispatch) { 
    14. 
  
  
  
  
  14.             scheduleConsumeBatchedInput(); 
    15. 
  
  
  
  
  15.         } 
    16. 
  
  
  
  
  16.         notifyRendererOfFramePending(); 
    17. 
  
  
  
  
  17.         pokeDrawLockIfNeeded(); 
    18. 
  
  
  
  
  18.     } 
    19. 
  
  
  
  
  19. } 
    20.

4、申请VSYNC同步信号

 
 
 
 
    
  
  
  
  
  1. Choreographer.java 
    2. 
  
  
  
  
  2. private void postCallbackDelayedInternal(int callbackType, 
    3. 
  
  
  
  
  3.         Object action, Object token, long delayMillis) { 
    4. 
  
  
  
  
  4.     synchronized (mLock) { 
    5. 
  
  
  
  
  5.         final long now = SystemClock.uptimeMillis(); 
    6. 
  
  
  
  
  6.         final long dueTime = now + delayMillis; 
    7. 
  
  
  
  
  7.         mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token); 
    8. 
  
  
  
  
  8.         if (dueTime <= now) { 
    9. 
  
  
  
  
  9.          
    10. 
  
  
  
  
  10.             scheduleFrameLocked(now); 
    11. 
  
  
  
  
  11.         }  
    12. 
  
  
  
  
  12.     } 
    13. 
  
  
  
  
  13. } 
    14.

5、scheduleFrameLocked

 
 
 
 
    
  
  
  
  
  1. // mFrameScheduled保证16ms内，只会申请一次垂直同步信号 
    2. 
  
  
  
  
  2. // scheduleFrameLocked可以被调用多次，但是mFrameScheduled保证下一个vsync到来之前，不会有新的请求发出 
    3. 
  
  
  
  
  3. // 多余的scheduleFrameLocked调用被无效化 
    4. 
  
  
  
  
  4. private void scheduleFrameLocked(long now) { 
    5. 
  
  
  
  
  5.     if (!mFrameScheduled) { 
    6. 
  
  
  
  
  6.         mFrameScheduled = true; 
    7. 
  
  
  
  
  7.         if (USE_VSYNC) { 
    8. 
  
  
  
  
  8.             if (isRunningOnLooperThreadLocked()) { 
    9. 
  
  
  
  
  9.                 scheduleVsyncLocked(); 
    10. 
  
  
  
  
  10.             } else { 
    11. 
  
  
  
  
  11.                 // 因为invalid已经有了同步栅栏，所以必须mFrameScheduled，消息才能被UI线程执行 
    12. 
  
  
  
  
  12.                 Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC); 
    13. 
  
  
  
  
  13.                 msg.setAsynchronous(true); 
    14. 
  
  
  
  
  14.                 mHandler.sendMessageAtFrontOfQueue(msg); 
    15. 
  
  
  
  
  15.             } 
    16. 
  
  
  
  
  16.         }   
    17. 
  
  
  
  
  17.     } 
    18. 
  
  
  
  
  18. } 
    19.
  • 在当前申请的VSYNC到来之前，不会再去请求新的VSYNC，因为16ms内申请两个VSYNC没意义;
  • 再VSYNC到来之后，Choreographer利用Handler将FrameDisplayEventReceiver封装成一个异步Message，发送到UI线程的MessageQueue;

6、FrameDisplayEventReceiver

 
 
 
 
    
  
  
  
  
  1. private final class FrameDisplayEventReceiver extends DisplayEventReceiver 
    2. 
  
  
  
  
  2.             implements Runnable { 
    3. 
  
  
  
  
  3.         private boolean mHavePendingVsync; 
    4. 
  
  
  
  
  4.         private long mTimestampNanos; 
    5. 
  
  
  
  
  5.         private int mFrame; 
    6. 
  
  
  
  
  6.         public FrameDisplayEventReceiver(Looper looper) { 
    7. 
  
  
  
  
  7.             super(looper); 
    8. 
  
  
  
  
  8.         } 
    9. 
  
  
  
  
  9.         @Override 
    10. 
  
  
  
  
  10.         public void onVsync(long timestampNanos, int builtInDisplayId, int frame) { 
    11. 
  
  
  
  
  11.             long now = System.nanoTime(); 
    12. 
  
  
  
  
  12.             if (timestampNanos > now) { 
    13. 
  
  
  
  
  13.              
    14. 
  
  
  
  
  14.                 timestampNanos = now; 
    15. 
  
  
  
  
  15.             } 
    16. 
  
  
  
  
  16.              
    17. 
  
  
  
  
  17.               if (mHavePendingVsync) { 
    18. 
  
  
  
  
  18.                 Log.w(TAG, "Already have a pending vsync event.  There should only be " 
    19. 
  
  
  
  
  19.                         + "one at a time."); 
    20. 
  
  
  
  
  20.             } else { 
    21. 
  
  
  
  
  21.                 mHavePendingVsync = true; 
    22. 
  
  
  
  
  22.             } 
    23. 
  
  
  
  
  23.              
    24. 
  
  
  
  
  24.             mTimestampNanos = timestampNanos; 
    25. 
  
  
  
  
  25.             mFrame = frame; 
    26. 
  
  
  
  
  26.             Message msg = Message.obtain(mHandler, this); 
    27. 
  
  
  
  
  27.              
    28. 
  
  
  
  
  28.             msg.setAsynchronous(true); 
    29. 
  
  
  
  
  29.             mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS); 
    30. 
  
  
  
  
  30.         } 
    31. 
  
  
  
  
  31.         @Override 
    32. 
  
  
  
  
  32.         public void run() { 
    33. 
  
  
  
  
  33.             mHavePendingVsync = false; 
    34. 
  
  
  
  
  34.              
    35. 
  
  
  
  
  35.             doFrame(mTimestampNanos, mFrame); 
    36. 
  
  
  
  
  36.         } 
    37. 
  
  
  
  
  37.     } 
    38.
  • 之所以封装成异步Message，是因为前面添加了一个同步栅栏，同步消息不会被执行;
  • UI线程被唤起，取出该消息，最终调用doFrame进行UI刷新重绘;

7、doFrame

 
 
 
 
    
  
  
  
  
  1. void doFrame(long frameTimeNanos, int frame) { 
    2. 
  
  
  
  
  2.     final long startNanos; 
    3. 
  
  
  
  
  3.     synchronized (mLock) { 
    4. 
  
  
  
  
  4.      
    5. 
  
  
  
  
  5.         if (!mFrameScheduled) { 
    6. 
  
  
  
  
  6.             return; // no work to do 
    7. 
  
  
  
  
  7.         } 
    8. 
  
  
  
  
  8.        long intendedFrameTimeNanos = frameTimeNanos; 
    9. 
  
  
  
  
  9.         startNanos = System.nanoTime(); 
    10. 
  
  
  
  
  10.         final long jitterNanos = startNanos - frameTimeNanos; 
    11. 
  
  
  
  
  11.          
    12. 
  
  
  
  
  12.         if (jitterNanos >= mFrameIntervalNanos) { 
    13. 
  
  
  
  
  13.             final long skippedFrames = jitterNanos / mFrameIntervalNanos; 
    14. 
  
  
  
  
  14.              
    15. 
  
  
  
  
  15.             if (skippedFrames >= SKIPPED_FRAME_WARNING_LIMIT) { 
    16. 
  
  
  
  
  16.              
    17. 
  
  
  
  
  17.                 Log.i(TAG, "Skipped " + skippedFrames + " frames!  " 
    18. 
  
  
  
  
  18.                         + "The application may be doing too much work on its main thread."); 
    19. 
  
  
  
  
  19.             } 
    20. 
  
  
  
  
  20.             final long lastFrameOffset = jitterNanos % mFrameIntervalNanos; 
    21. 
  
  
  
  
  21.                  
    22. 
  
  
  
  
  22.             frameTimeNanos = startNanos - lastFrameOffset; 
    23. 
  
  
  
  
  23.         } 
    24. 
  
  
  
  
  24.         if (frameTimeNanos < mLastFrameTimeNanos) { 
    25. 
  
  
  
  
  25.              
    26. 
  
  
  
  
  26.             scheduleVsyncLocked(); 
    27. 
  
  
  
  
  27.             return; 
    28. 
  
  
  
  
  28.         } 
    29. 
  
  
  
  
  29.            
    30. 
  
  
  
  
  30.         mFrameInfo.setVsync(intendedFrameTimeNanos, frameTimeNanos); 
    31. 
  
  
  
  
  31.          
    32. 
  
  
  
  
  32.         mFrameScheduled = false; 
    33. 
  
  
  
  
  33.          
    34. 
  
  
  
  
  34.         mLastFrameTimeNanos = frameTimeNanos; 
    35. 
  
  
  
  
  35.     } 
    36. 
  
  
  
  
  36.     try { 
    37. 
  
  
  
  
  37.           
    38. 
  
  
  
  
  38.         Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Choreographer#doFrame"); 
    39. 
  
  
  
  
  39.          
    40. 
  
  
  
  
  40.         mFrameInfo.markInputHandlingStart(); 
    41. 
  
  
  
  
  41.         doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos); 
    42. 
  
  
  
  
  42.          
    43. 
  
  
  
  
  43.         mFrameInfo.markAnimationsStart(); 
    44. 
  
  
  
  
  44.         doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos); 
    45. 
  
  
  
  
  45.          
    46. 
  
  
  
  
  46.         mFrameInfo.markPerformTraversalsStart(); 
    47. 
  
  
  
  
  47.         doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos); 
    48. 
  
  
  
  
  48.          
    49. 
  
  
  
  
  49.         } else { 
    50. 
  
  
  
  
  50.          
    51. 
  
  
  
  
  51.             mPrivateFlags |= PFLAG_DRAWN | PFLAG_DRAWING_CACHE_VALID; 
    52. 
  
  
  
  
  52.             mPrivateFlags &= ~PFLAG_DIRTY_MASK; 
    53. 
  
  
  
  
  53.         } 
    54. 
  
  
  
  
  54.         return renderNode; 
    55. 
  
  
  
  
  55.     } 
    56.

10、绘制总结

  • android最高60FPS，是VSYNC及决定的，每16ms最多一帧;
  • VSYNC要客户端主动申请，才会有;
  • 有VSYNC到来才会刷新;
  • UI没更改，不会请求VSYNC也就不会刷新;

总结

 

关于绘制还有很多知识点，后面会总结陆续发出来的;

本文名称：Vsync信号机制和UI刷新流程
标题链接：http://www.hantingmc.com/qtweb/news15/465365.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

微信公众号知识

分类信息网站

绵阳电信机房　　 　定制网站　　 　成都服务器托管　　 　宜宾网站营销推广　　 　新网创想　　 　宜宾网站建设　　 　铁科精智测控　　 　鸿艺文化传播　　 　成都托管服务器　　 　复盛机电设备安装　　 　高端网站设计　　 　成都网站设计　　 　双流网站建设　　 　成都广告公司　　 　微信小程序开发　　 　网站设计　　 　大英泰恒网站　　 　中国电信西部信息中心机房　　 　腾讯免备案空间　　 　达州做网站