每一帧的绘制是生产者消费者模式
Android 整个「每一帧渲染到屏幕」的链路，从 App 端的 ViewRootImpl 到最终显示在面板（Display），本质上就是 典型的生产者-消费者模型。核心组件与数据流如下：
生产者（Producer）
• App 主线程的 Choreographer → ViewRootImpl → SurfaceFlinger 的 BufferQueue
• 每 16.7 ms（60 Hz）收到 VSync 信号后，主线程/RenderThread 把 UI 树绘制到一块 GraphicBuffer （OpenGL / Vulkan 渲染结果）。
• 绘制完成把这块 buffer queue 进 SurfaceFlinger 的 BufferQueue → 生产者完成一次"生产"。
缓冲区（Queue）
• BufferQueue 是 Binder 跨进程对象，内部维护 最多 2~3 个 slot （双缓冲/三缓冲）。
• 当 App 把 buffer 放入队列后，会立即拿到下一块空闲 buffer 继续下一帧的生产。
消费者（Consumer）
• SurfaceFlinger 作为消费者进程，在收到 HW-VSync 或 软件 VSync 后，从 BufferQueue dequeue 最新一帧 buffer。
• 把该帧做合成（Composition，可能叠加多图层），然后提交给 Display HAL（HWComposer），最终驱动面板刷新。
同步与背压
• 如果 App 生产过快（丢帧），BufferQueue slot 满，dequeueBuffer 会 阻塞 生产者，形成背压。
• 如果生产过慢，消费者拿不到新 buffer，就继续显示上一帧 → 用户感觉卡顿。
App 每帧把渲染结果"生产"进 BufferQueue，SurfaceFlinger 作为"消费者"取帧送显；这套机制就是 生产者-消费者 + 双/三缓冲 + VSync 同步 的经典实现。
vsync信号来临到生成一帧流程
Choreographer.FrameDisplayEventReceiver.onVsync
Vsync信号来临会调用到android的Choreographer.FrameDisplayEventReceiver.onVsync方法
在该方法中发送异步消息到主线程
复制代码
public void onVsync(long timestampNanos, long physicalDisplayId, int frame,
VsyncEventData vsyncEventData) {
//发送异步消息
Message msg = Message.obtain(mHandler, this);
//true这里是异步消息
msg.setAsynchronous(true);
mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);
处理异步消息
复制代码
//主线程调用异步消息，开始绘制流程
@Override
public void run() {
mHavePendingVsync = false;
doFrame(mTimestampNanos, mFrame, mLastVsyncEventData);
}
各种事件开始处理
复制代码
void doFrame(long frameTimeNanos, int frame,
DisplayEventReceiver.VsyncEventData vsyncEventData) {
//输入事件 触摸、按键、轨迹球、鼠标事件
doCallbacks(Choreographer.CALLBACK_INPUT, frameData, frameIntervalNanos);
mFrameInfo.markAnimationsStart();
//普通动画 ValueAnimator、ObjectAnimator、View.animate() 等属性动画的下一帧计算。
doCallbacks(Choreographer.CALLBACK_ANIMATION, frameData, frameIntervalNanos);
//insets 动画 与系统窗口（IME、系统栏）同步的边衬动画，比如键盘弹出/收回动画。
doCallbacks(Choreographer.CALLBACK_INSETS_ANIMATION, frameData,
frameIntervalNanos);
mFrameInfo.markPerformTraversalsStart();
//遍历 / 刷新布局 ViewRootImpl.scheduleTraversals() 安排的 performTraversals()------测量、布局、绘制；invalidate() 最终走到这里。
doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameData, frameIntervalNanos);
//帧提交 / 收尾 在 draw() 完成、SurfaceFlinger 消费前做最后的 Buffer 提交 与 帧统计；也用于 FrameMetrics 打点。
doCallbacks(Choreographer.CALLBACK_COMMIT, frameData, frameIntervalNanos);
Choreographer.doCallbacks(Choreographer.CALLBACK_TRAVERSAL
处理绘制相关流程
复制代码
void doCallbacks(int callbackType, FrameData frameData, long frameIntervalNanos) {
try {
Trace.traceBegin(Trace.TRACE_TAG_VIEW, CALLBACK_TRACE_TITLES[callbackType]);
for (CallbackRecord c = callbacks; c != null; c = c.next) {
//分发事件，这里调用的是ViewRootImpl.mTraversalRunnable.run
c.run(frameData);
}
开始刷新
ViewRootImpl.mTraversalRunnable.run
复制代码
final class TraversalRunnable implements Runnable {
@Override
public void run() {
//开始度量，布局，绘制
doTraversal();
}
}
void doTraversal() {
//如果没有请求刷新，Vsync信号来将不会刷新
if (mTraversalScheduled) {
//修改标志位
mTraversalScheduled = false;
//移除消息屏障，这个执行后才会执行普通消息
mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);
if (mProfile) {
Debug.startMethodTracing("ViewAncestor");
}
//开始测量，布局，绘制
performTraversals();
if (mProfile) {
Debug.stopMethodTracing();
mProfile = false;
}
}
}
ViewRootImpl.performTraversals
// 开始测量，布局，绘制
performTraversals();
复制代码
private void performTraversals() {
//度量
performMeasure()
//布局
performLayout(lp, mWidth, mHeight);
//绘制
performDraw()
}
ViewRootImpl.performMeasure
复制代码
private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
if (mView == null) {
return;
}
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
try {
//顶层View开始下发度量
mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
}
ViewRootImpl.performLayout
复制代码
private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
int desiredWindowHeight) {
final View host = mView;
if (host == null) {
return;
}
try {
//顶层View开始度量
host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
ViewRootImpl.performDraw
复制代码
private boolean performDraw() {
try {
boolean canUseAsync = draw(fullRedrawNeeded, usingAsyncReport && mSyncBuffer);
if (usingAsyncReport && !canUseAsync) {
mAttachInfo.mThreadedRenderer.setFrameCallback(null);
usingAsyncReport = false;
}
}
}
private boolean draw(boolean fullRedrawNeeded, boolean forceDraw) {
drawSoftware
}
private boolean draw(boolean fullRedrawNeeded, boolean forceDraw) {
// 如果脏区域非空、正在做动画，或无障碍焦点变化，则真正进入绘制
if (!dirty.isEmpty() || mIsAnimating || accessibilityFocusDirty) {
// ---- 硬件加速路径（默认开启） ----
if (isHardwareEnabled()) {
// 把 View 树封装成 DisplayList，通过 Binder 交给 RenderThread
// 由 GPU 异步完成真正的绘制与上屏
mAttachInfo.mThreadedRenderer.draw(mView, mAttachInfo, this);
// ---- 软件绘制路径（硬件加速关闭或 Surface 不支持） ----
} else {
// 直接在 UI 线程用 Skia/Canvas 把 View 画到 Surface
if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset,
scalingRequired, dirty, surfaceInsets)) {
// 软件绘制失败，直接返回 false
return false;
}
}
}
// 本次绘制流程结束，返回是否使用异步帧报告
return useAsyncReport;}
private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
boolean scalingRequired, Rect dirty, Rect surfaceInsets) {
mView.draw(canvas);
}
生产数据交给消费者消费
android处理完后会交给消费者消费
请求下一次Vsync信号来需要刷新流程
View. assignParent
复制代码
void assignParent(ViewParent parent) {
if (mParent == null) {
mParent = parent;
} else if (parent == null) {
mParent = null;
} else {
throw new RuntimeException("view " + this + " being added, but"
+ " it already has a parent");
}
}
最顶层View
最顶层View的mParent是通过ViewRootImpl的setView方法添加的时候注入的
复制代码
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView,
int userId)
view.assignParent(this);
}
View树下发Parent
是通过ViewGroup设置下发的
复制代码
是通过ViewGroup设置下发的
private void addViewInner(View child, int index, LayoutParams params,
boolean preventRequestLayout)
if (preventRequestLayout) {
child.assignParent(this);
} else {
child.mParent = this;
}
View. Invalidate
内容变化但是大小不变化会触发该方法，该方法在硬件加速打开的时候不会出现崩溃，不会进行线程检查checkThread()
在调节满足的情况下ViewGroup的invalidateChil逐级上报，最后上报到顶层ViewGroup中
最顶层是
复制代码
void invalidateInternal(int l, int t, int r, int b, boolean invalidateCache,
boolean fullInvalidate) {
if (p != null && ai != null && l < r && t < b) {
final Rect damage = ai.mTmpInvalRect;
damage.set(l, t, r, b);
p.invalidateChild(this, damage);
}
public final void invalidateChild(View child, final Rect dirty) {
final AttachInfo attachInfo = mAttachInfo;
//开启硬件加速后执行该位置
if (attachInfo != null && attachInfo.mHardwareAccelerated) {
// HW accelerated fast path
onDescendantInvalidated(child, child);
return;
}
调用流程是
View.invalidate->ViewGroup.invalidateChild->ViewGroup.invalidateChild->......->最顶层ViewGroup.invalidateChild->ViewRootImpl.invalidateChild
View. requestLayout
控件大小变化后会执行该方法，方法在硬件加速开启的情况下也会进行线程检查
会调用ViewGroup的requestLayout
复制代码
public void requestLayout() {
if (mParent != null && !mParent.isLayoutRequested()) {
mParent.requestLayout();
}
调用流程是View.requestLayout->ViewGroup.requestLayout->ViewGroup.requestLayout->......->最顶层ViewGroup.requestLayout->ViewRootImpl.requestLayout
ViewRootImpl . requestLayout
复制代码
@Override
public void requestLayout() {
if (!mHandlingLayoutInLayoutRequest) {
//线程检查
checkThread();
mLayoutRequested = true;
//开始消息屏障，入队
scheduleTraversals();
}
}
ViewRootImpl. scheduleTraversals 消息屏障入队
复制代码
void scheduleTraversals() {
//设置标志位，每一次Vsync期间只会插入一次，没有移除消息屏障不会再次插入
if (!mTraversalScheduled) {
//修改标志位
mTraversalScheduled = true;
//开启消息屏障，记录屏障token
mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
//将消息放入Choreographer中
mChoreographer.postCallback(
Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
notifyRendererOfFramePending();
pokeDrawLockIfNeeded();
}
}
Choreographer.postCallback入队刷新消息
入队消息，等待vsync信号来临取出
复制代码
private void postCallbackDelayedInternal(int callbackType,
Object action, Object token, long delayMillis) {
synchronized (mLock) {
//消息进入队列中
mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);
}
硬件加速开启后View刷新
在开启硬件加速的情况下，View的大小未改变，之改变内存，是不会进行线程检查的
不会检查线程，只有大小改变了触发了requestLayout会崩溃
复制代码
View.invalidateChild
public final void invalidateChild(View child, final Rect dirty) {
final AttachInfo attachInfo = mAttachInfo;
//开启硬件加速后执行该位置
if (attachInfo != null && attachInfo.mHardwareAccelerated) {
// HW accelerated fast path
onDescendantInvalidated(child, child);
return;
}
View.onDescendantInvalidated
@Override
public void onDescendantInvalidated(@NonNull View child, @NonNull View descendant) {
// TODO: Re-enable after camera is fixed or consider targetSdk checking this
// checkThread();
if ((descendant.mPrivateFlags & PFLAG_DRAW_ANIMATION) != 0) {
mIsAnimating = true;
}
//开启硬件加速后不会检查线程
invalidate();
}
View.post获取宽高原理
入口
View.post()
复制代码
public boolean post(Runnable action) {
final AttachInfo attachInfo = mAttachInfo;
if (attachInfo != null) {
// 已经 attach，直接丢给主线程 Handler
return attachInfo.mHandler.post(action);
}
// 还没 attach，先缓存
getRunQueue().post(action);
return true;
}
View.postDelayed
复制代码
/**
* 将 Runnable 延迟主线程执行的安全入口。
*
* 1. 如果 View 已经挂载到窗口（attachInfo 非空），
* 直接通过 ViewRootImpl 的主线程 Handler 分发，
* 保证 run 代码运行在 **主线程** 且按时触发。
*
* 2. 如果 View 尚未挂载（例如刚 new 出来、还没 addView），
* 先把它放进 **View 的 RunQueue** 缓存起来；
* 等到 dispatchAttachedToWindow() 时再整体迁移到主线程 Handler。
* 这样即使提前 post 也不会丢失任务，更不会在非法线程执行。
*
* @param action 待执行代码块
* @param delayMillis 延迟时间（毫秒）
* @return true 表示成功入队（与 Handler 返回值一致）
*/
public boolean postDelayed(Runnable action, long delayMillis) {
final AttachInfo attachInfo = mAttachInfo; // 取挂载信息（ViewRootImpl 提供）
if (attachInfo != null) {
// 已挂载：直接交给主线程 Handler
return attachInfo.mHandler.postDelayed(action, delayMillis);
}
// 未挂载：先放进 RunQueue，等 attach 后一次性迁移到主线程
getRunQueue().postDelayed(action, delayMillis);
return true;
}
attach 前：RunQueue 缓存
View.getRunQueue
复制代码
/**
* 返回当前 View 的"延迟任务队列"单例。
* 第一次调用时懒创建 HandlerActionQueue，用来缓存尚未 attach 时通过
* post/postDelayed 提交的 Runnable；等 View 被挂载到窗口后再整体迁移到主线程 Handler。
*/
private HandlerActionQueue getRunQueue() {
if (mRunQueue == null) { // 懒加载，避免无谓对象
mRunQueue = new HandlerActionQueue();
}
return mRunQueue;
}
HandlerActionQueue.post
复制代码
/**
* 将 Runnable 立即放入队列（延迟 0 ms）。
* 内部直接调用 postDelayed，简化入口。
*/
public void post(Runnable action) {
postDelayed(action, 0);
}
/**
* 把 Runnable 及其延迟时间包装成 HandlerAction 并加入数组。
* 数组满时自动扩容，保证线程安全。
*/
public void postDelayed(Runnable action, long delayMillis) {
// 1. 封装任务
final HandlerAction handlerAction = new HandlerAction(action, delayMillis);
// 2. 线程安全地加入数组
synchronized (this) {
if (mActions == null) {
mActions = new HandlerAction[4]; // 初始容量 4
}
// GrowingArrayUtils.append：若数组已满则自动 2 倍扩容
mActions = GrowingArrayUtils.append(mActions, mCount, handlerAction);
mCount++; // 元素个数 +1
}
}
attach 后：layout 完成 → 搬到主线程
当 ViewRootImpl 第一次 performTraversals() 完成后，会调用：
ViewRootImpl.performTraversals
复制代码
private void performTraversals() {
...
if (mFirst) {
host.dispatchAttachedToWindow(mAttachInfo, 0);
}
...
}
在 dispatchAttachedToWindow() 链路上，View 把缓存的 Runnable 全部搬到主线程：
View.dispatchAttachedToWindow
复制代码
void dispatchAttachedToWindow(AttachInfo info, int visibility) {
mAttachInfo = info;
...
// 把之前缓存的 RunQueue 搬到主线程 Handler
if (mRunQueue != null) {
mRunQueue.executeActions(info.mHandler);
mRunQueue = null;
}
...
}
HandlerActionQueue.executeActions
复制代码
public void executeActions(Handler handler) {
synchronized (this) {
final HandlerAction[] actions = mActions;
for (int i = 0, count = mCount; i < count; i++) {
final HandlerAction handlerAction = actions[i];
handler.postDelayed(handlerAction.action, handlerAction.delay);
}
mActions = null;
mCount = 0;
}
}
最终执行：拿到宽高
由于搬运发生在 performTraversals() 之后，此时 View 已经 measure/layout 完毕，Runnable 在主线程执行时自然可以安全地读取宽高。
一句话总结
View.post() 先缓存，等 attach + layout 完成后一次性搬到主线程，所以一定能拿到宽高；而 Handler.post() 没有 attach & layout 语义，因此不能保证。