从 Traceview 到 Perfetto:Android Profiler 每个面板,我都配了一次真实翻车

2 阅读54分钟

九月三号下午,测试把一台 Redmi Note 11 递过来,说健康档案列表滑起来一顿一顿的。我插上线,打开 CPU Profiler,选默认的 Sample Java Methods,录了十秒滑动。CPU 曲线最高 8%,火焰图上主线程几乎被 android.os.MessageQueue.nativePollOnce 铺满,绿油油一片,找不出哪个方法吃了时间。我在群里回了句「不是 CPU 的问题,估计是机型适配或者 GPU」。

这句话让我多花了两天。

第三天换到 Trace System Calls 才看明白:那十秒里主线程有 37 次超过 30ms 的空档,最长 87ms,状态全是 Runnable 或者等 binder 回包;Choreographer#doFrame 被顶到 43ms。根因是 onBindViewHolder 里每次都查一次 Room,而那条查询还要跨进程过一次 ContentProvider 的 binder。CPU 低恰恰不是「没活干」,是线程一直在等,等的时间压根不进 CPU 采样。

我盯着那张 8% 的火焰图看了半小时,它没撒谎,它只是不测这个。Profiler 这四代加了一堆面板,每个面板给你的都是被抽象过一层的数;会用工具不是会点 Record,是知道这个数谁给的、怎么给的、以及它没测什么。 后面我把每个面板都配了一次真实翻车,也是从这次开始养成的习惯。

我这边的项目是个健康类 App,模块 M 归我,包名正文里统一写 com.example.health。机器是 Pixel 6 和那台 Redmi Note 11,Android Studio 从 3.0 一路用到 Hedgehog 之后的几个版本,AGP 8.2.2、compileSdk 34、minSdk 24。数字都是我自己机器上跑出来的,换设备换版本不会一模一样。

这四代工具,换掉的其实不是按钮

现在 IDE 里那一排时间线,看着像是同一个东西长出来的,其实前后换过四拨完全不同的采集机制。

最早那拨叫 DDMS(Dalvik Debug Monitor Server),是 SDK tools/ 目录下一个独立的 Swing 程序。要看方法耗时就开 Traceview——在代码里手写 Debug.startMethodTracing("x"),跑完 stopMethodTracing(),把 .trace 拉出来看。它靠全量插桩工作,每个方法进出都记时间戳,应用会慢到亲妈都不认识,所以拿它判断「这段代码到底多快」纯属自欺欺人,只能看谁调了谁。要看帧和调度就换 Systrace 命令行,要看视图层级开 Hierarchy Viewer,要看流量开 Network Traffic tool。四个工具四套数据,时间轴对不齐,一次卡顿得开四个窗口手动比。

2017 年 10 月 Android Studio 3.0 把 Android Monitor 整个换成了 Android Profiler。真正的变化不是按钮变好看,是 CPU、Memory、Network 三条时间线共用顶上那条 Event 时间轴——Activity 状态、触摸、按键、屏幕旋转都在同一条轴上标出来。第一次能指着一次具体交互说「就是这一下,三条线同时动了」。logcat 被挪出去成了独立窗口,另外加了 Profile or debug APK,不用从工程构建也能直接剖析一个可调试的包。

官方在弃用 Device Monitor 时给过一张替代表,我把它抄进了自己的笔记,后来每次升级 IDE 都拿出来对一遍:

被替掉的现在用替掉的本质
DDMS 的 CPU / 内存 / 网络监控Android Studio 3.0+ 的 Android Profiler分散窗口 → 统一时间轴
TraceviewCPU Profiler(也能导入 .trace)手写埋点全量插桩 → 可选采样 / 插桩
Systrace 命令行命令行 systrace,或 CPU Profiler 里的 System Trace单一 HTML 报告 → 可交互、可对齐 Event 轴
Hierarchy Viewer / Pixel PerfectLayout Inspector静态层级快照 → 运行时视图树 + 属性
Network Traffic toolNetwork Profiler只有流量字节数 → 单条请求 / 响应 / 线程
Device File Explorer 之外的 DDMS 杂项adb、模拟器扩展控件、Debugger 窗口一个大杂烩 → 各归各位

Device Monitor 在 3.1 标记为废弃,3.2 里彻底移除。同一波里,3.1 给 Network Profiler 补了 Request tab 和 Thread View(以前只有 Connection View),CPU Profiler 多了 Sampled (Native);3.2 在 2018 年 9 月一口气加了 Energy Profiler、CPU Profiler 的 System Trace 配置、Profiler Sessions、用 Debug API 自动起停录制、启动时自动录制,以及 Memory Profiler 里的 JNI heap。Energy 要 API 26+,System Trace 要 API 24+,JNI heap 也要 API 26——那阵子很多人的测试机还停在 7.1,这些功能等于没有,我第一次照着教程点 Energy 就扑了个空,换成 Android 8.0 的机器才出现那一行。

2019 年 9 月 Android 10(API 29)把 Perfetto 做成平台级追踪。这一步当时在 IDE 上几乎没感觉,System Trace 还是那个 System Trace,但底下从 systrace 的压缩文本换成了 Protobuf 的 TracePacket,数据源从几类扩到 ftrace、heapprofd、java_hprof、android.power、android.log 一大堆,还能拿 SQL 查。等于把工具的输出从「一张只能看的报告」变成了「一个能查的数据库」。

2020 年 3.6 给 Memory Profiler 加了 Activity / Fragment 泄漏自动检查;2021 年 Arctic Fox(2020.3.1)把版本号改成年份制,开出 App Inspection 入口,Background Task Inspector 要求 WorkManager 2.5.0+ 且设备 API 26+,Memory Profiler 换了新录制界面,还多了 Layout Validation 和无障碍扫描。2022 年 Chipmunk(2021.2.1)让 CPU Profiler 在 Android 12 / API 31 以上显示更细的卡顿信息,Flamingo 之后 Network Inspector 默认铺满完整时间线的流量。

真正让我把「估算」和「实测」分开的是 2023 年 11 月的 Hedgehog(2023.1.1)。新 Power Profiler 不再算模型,改从设备端电源轨监视器 ODPM 读各个子系统的真实功率,按 Power Rails 分栏,数据挂在同一条 System Trace 里。老 Energy Profiler 显示的是「估算能耗」,把 CPU、网络、定位的活动按模型折算成一个相对值;新的是 mA / mW 级别的实际读数。代价是门槛高:要 Pixel 6 往后、Android 10+ 的设备,我那台 Redmi 直接没有这一行。官方有个 Kuro Games 的案例,《鸣潮》用 Power Profiler 加 ODPM 做 A/B,最后把耗电降了 9.68%;他们后来干脆用 Perfetto Trace Processor 的 android_powerrails metric 自己取 30 秒 session 的 avg_used_power_mw 做版本对比。

到 2025 年 I/O,方向又变了一次:Android Studio 里的 Agent 能直接激活一个叫 Perfetto trace analysis 的技能,自己下载 trace processor、真的去查 trace 验证假设,而不是对着火焰图给一句笼统建议;LeakCanary 也被内嵌进 IDE,检测到泄漏旁边直接给修复按钮。工具从「给你看」开始往「替你查」走。

时间版本 / API具体变化我当时踩的坑
2008~2016DDMS 时代Traceview 全量插桩、Systrace、Hierarchy Viewer 各自独立四个窗口时间轴对不齐
2017-10AS 3.0Profiler 取代 Android Monitor,三条时间线共用一个 Event 轴,logcat 独立,Profile or debug APK以为只是换了 UI
2018-03AS 3.1Device Monitor 废弃;Network 加 Request / Thread View;CPU 加 Sampled (Native)没注意旧面板位置变了
2018-09AS 3.2 / API 26Energy Profiler、System Trace、Sessions、Debug API 自动录制、JNI heap7.1 测试机上找不到 Energy 行
2019-09Android 10 / API 29Perfetto 成为平台追踪,Protobuf + SQL还拿 systrace 脚本往新机上套
2020AS 3.6Memory Profiler 自动检查 Activity / Fragment 泄漏误把 Fragment 缓存当泄漏
2021Arctic Fox 2020.3.1版本号改年份制;App Inspection、Background Task Inspector、Memory 新录制界面按老教程找 Profiler 里的后台任务
2022Chipmunk / FlamingoAPI 31+ 显示更细卡顿信息;Network Inspector 默认全时间线低版本机器上看不到帧信息
2023-11Hedgehog 2023.1.1Power Profiler 走 ODPM 实测,替掉 Energy 的估算模型拿 Redmi 找电源轨,白找半天
2025I/O 2025Agent 调 Perfetto trace analysis 查 trace;LeakCanary 内嵌 IDE还得学会把问题问成可验证的假设

有些老办法是真失效了:靠 Debug.startMethodTracing 手写埋点判断耗时、单看 CPU 占用率判断卡不卡、把 Energy 的估算值当电量绝对值、拿 Hierarchy Viewer 量布局。也有些绕回来了:命令行 am profile / am dumpheap 采集在 CI 里反而成了主力,Trace.beginSection 自定义打点在 Perfetto 时代比 systrace 年代更有用,Sessions 导出的 .trace / .hprof 离线比对又变回日常。

四代看下来,变的不是按钮数量,是每一代都在把「现象」往「可归因、可复现、可查询」推一步。DDMS 给你现象,3.0 把现象对齐到同一次交互,3.2 开始给归因(谁唤醒了、谁分配了),Perfetto 把数据变成能查的结构,Hedgehog 把估算换成实测,AI 那一层在试着替你做第一轮假设验证。会用工具的门槛也跟着从「记得住菜单」抬到「问得出对的问题」。

三套采集机制,决定了每个面板能看见什么

所有面板,剥到最底下就三种取数方式,外加一个「估算还是实测」的分野。把这四个分清楚,界面上那些看不懂的读数基本都能自己解释。

flowchart TB
  subgraph APP[应用进程]
    A[Java / Kotlin 方法] --> B[ART 调用栈]
    C[Native 代码] --> D[malloc / simpleperf]
    E[Framework 埋点] --> F[atrace / Trace.beginSection]
  end
  subgraph KERN[内核与系统]
    G[ftrace ring buffer] --> H[sched_switch / binder / freq]
    I[ODPM 电源轨] --> J[Power Rails mW]
    K[fuel gauge] --> L[电量计]
  end
  subgraph COLLECT[采集层]
    B --> M[定时抓栈: 采样]
    B --> N[方法进出打点: 插桩]
    D --> O[heapprofd / 符号表]
    F --> P[traced_probes]
    H --> P
    J --> P
    P --> Q[traced: Protobuf TracePacket]
    L --> R[模型折算: 估算能耗]
  end
  Q --> S[Profiler 时间线 / Perfetto UI / SQL]
  M --> S
  N --> S
  O --> S
  R --> S

第一种是采样。Sample Java Methods 按固定间隔(默认大概 1000μs,可以自己改)去抓一次应用所有 Java 线程的调用栈,抓够一堆样本后统计「哪些栈出现得多」,据此推时间和 CPU 占用。开销小,能录很久,适合先扫一遍找热点。两个盲区得记死:执行时间短于采样间隔的方法可能整个漏掉;线程不在 Running 状态时,那段时间不会贡献 CPU 样本。九月那次 8% 就是撞在第二个盲区上——主线程在等 binder 和 SQLite,采样器抓到的是它睡在 nativePollOnce 里的样子,等的那 87ms 被算成「没干活」。

第二种是插桩。Trace Java Methods 在每个方法入口和出口写时间戳,于是调用次数、调用关系、Self / Children / Total time 都精确。代价是每次方法调用都多一堆指令,实测整体慢 2 到 10 倍不等,方法越碎越夸张。所以我只拿它回答「这段代码到底调了哪些方法」,绝不拿它的耗时数字下结论。有一次我拿着插桩录出来的 240ms 去跟产品说接口解析慢,改成采样再录是 31ms,那 240ms 里大半是探针自己。AS 3.2 之后还能用 Debug.startMethodTracing() / stopMethodTracing() 让 IDE 自动起停录制,跑配置里也能勾「启动时录制方法跟踪」,本质还是这一套。

第三种是事件追踪。Trace System Calls 不关心 Java 方法,它读内核 ftrace 的 sched_switch、sched_wakeup、binder_transaction,加上 Framework 预埋的 atrace tag(gfx / view / am / wm / input / disk),还原出每个线程在什么时刻是 Running、Runnable、Sleeping 还是 Uninterruptible,各核忙不忙,一帧从 Choreographer#doFrame 到 RenderThread 到 GPU 走了多久。开销低,时间精度高,但只看得见有埋点的地方——想让业务代码出现在图上,得自己加 Trace.beginSection。这条线在 Android 10 之后落到 Perfetto:traced 守护进程管缓冲区和路由,traced_probes 从 ftrace / /proc / heapprofd / ODPM 取数,数据以共享内存零拷贝交回去,序列化成 TracePacket 写进文件,最后在 Perfetto UI 或者用 trace_processor 的 SQL 查。

第四件事最容易被忽略:估算和实测不是一个东西。老 Energy Profiler 那根柱子是把 CPU、网络、定位的活动量套进一个模型折算出来的相对能耗,用来比较「我这次改动有没有让系统事件变多」挺好,拿来当 mA·h 报给产品就是胡说。Hedgehog 的 Power Profiler 读的是 ODPM 硬件电源轨的真实功率,能给出 power.rail.cpu.big、power.rail.gpu 这种分项,但只有部分 Pixel 支持,而且看的是整机子系统,不是「你这个 App 用了多少电」——归因还得靠 trace 里的时间对齐。

Memory Profiler 的 heap dump 又是另一类:它不是时间序列,是某个瞬间把堆里所有存活对象连同引用图整个拍下来(HPROF)。曲线告诉你趋势,dump 告诉你这一刻谁还活着、谁在引用它。两者混着看才不会得出「内存没涨所以没泄漏」这种结论。

把九月那次掉帧摆到各个面板里,同一件事长得完全不一样:

面板它给出的数这次它显示它看不见的
CPU Profiler / Sample Java采样命中栈的占比CPU 8%,nativePollOnce 铺满等 I/O 与等锁的 87ms
CPU Profiler / Trace System Calls线程状态时序、各核、binder、帧Runnable 长条、doFrame 43ms、binder 回包具体哪个 Java 方法热点
Memory Profiler分类曲线、Allocated 虚线、堆快照GC 图标密集,虚线呈锯齿谁在等 binder
Network Profiler连接、线程、单条请求响应一片空,没有任何请求本地 DB 与跨进程调用
Energy / Power Profiler估算能耗 / 电源轨 mW几乎没有波动秒级掉帧这种短事件
Layout Inspector视图树、重组计数列表项 11 层嵌套,滑动时重组计数飙到 300+耗时数值
App Inspection表数据、任务队列每次 bind 都跟着一条 SELECT内核调度与锁
用户手指顿挫感「滑起来一顿一顿的」上面全部

这张表我后来贴在工位上。它比记住七个面板的菜单位置有用得多:拿到一个性能问题,先问「这个现象更像哪种缺席」,再决定开哪个面板,而不是七个全开然后被信息淹掉。

CPU Profiler:先看它是怎么录的

这个面板被误用得最多,多半是因为一进去就有四个录制配置,而下拉框不会告诉你选错了会得出什么结论。

界面本身分三层。最上面是共用的 Event 时间轴;中间是 CPU 时间线,除了自己进程的实时占用率(占总可用 CPU 时间的百分比)和线程总数,还会叠一条其他进程的占用,方便判断「是不是整机都在忙」;下面是线程 Activity 时间线,每个线程一条,绿色是正在跑或可运行,黄色是卡在 I/O 上等资源,灰色是睡着没消耗 CPU。这三层加上录制配置下拉和 Record 按钮,就是全部入口。

四种配置的差别,我踩过一遍才记住:

配置取数方式设备要求能回答什么不能回答什么
Sample Java Methods按间隔抓 Java 调用栈无特殊要求哪段代码总体最吃 CPU短方法的耗时、等待时间
Trace Java Methods每个方法进出打时间戳无特殊要求一次操作究竟调了哪些方法、调了几次真实耗时(探针拖慢 2~10 倍)
Sample C/C++ Functionsnative 线程采样,底层 simpleperfAPI 26+,且带符号表JNI / 音视频 / 端侧推理的 native 热点Java 层调用关系
Trace System Callsftrace + atrace 事件API 24+线程状态、锁与 binder 等待、帧、各核瓶颈Java 方法级热点

九月那次我选的是第一种,于是得到一个「CPU 8%」的正确结论和一个「不是 CPU 问题」的错误判断。它俩不矛盾:采样统计的是线程真正占用 CPU 的那些样本,线程在 Runnable 排队、等 binder 回包、等 SQLite 锁,都不产生 CPU 样本。界面上还有个 Wall clock time / Thread time 的切换,选 Thread time 会把「没消耗 CPU 的那部分」从耗时里扣掉——这个开关本身就说明,工具作者知道同一段调用有两种完全不一样的时长口径。

四个视图不是四种装饰,是四种不同的问法:

  • Call Chart 横轴是真实时间,纵轴自上而下是调用关系。橙色是系统 API,绿色是自己的代码,蓝色是三方库(Java 语言 API 也算蓝色)。要看「这一下为什么拖了 80ms」,从主线程那条长条往下剥最直接。
  • Flame Chart 把相同调用路径的栈合并,横轴变成相对执行时间占比,纵轴倒过来,调用者在下、被调用者在上。它故意丢掉时间信息,所以适合找「累计最宽的那条路径」,不适合回答「是哪一帧发生的」。有个细节容易漏:相同调用顺序才会合并,A→D→B→C 和 A→D→C 不会并到一起。
  • Top Down 是表格,展开节点看它调了谁,每个节点给 Self(自己代码花的时间)、Children(被调方花的时间)、Total(两者之和)。想知道「这个 43ms 里到底哪一层是自己的锅」,用这个。
  • Bottom Up 反过来,展开节点看谁调了它。热点方法已经知道名字、想找出所有调用来源时特别快。注意它的时间口径是基于被展开节点的,跟 Top Down 里的同名方法数字不一样,不是工具算错了。

还有几个不写在界面上的东西。IDE 会往应用进程里塞自己的线程——JDWP、Profile Saver、Studio:VMStats、Studio:Perfa、Studio:Heartbeat——它们的 CPU 也会被算进进程总账,盯着某个诡异线程查半天之前先看名字。录制配置里的 Sampling interval 单位是微秒,API 26+ 的设备不再受文件大小限制,老设备上录太长会撞到上限然后静默停止收集新数据。右上角 Filter(Ctrl+F)能按方法、类、包名过滤,Flame Chart 里命中的栈会被高亮并挪到左边,几万行的 trace 全靠它。

用一棵调用树,把四个视图的数字算一遍

刚上手时我把四个视图当成四种皮肤,后来才明白它们是同一堆样本按四种方式重排。拿一次 onBindViewHolder 的 40ms 举例,调用关系长这样:

onBindViewHolder                 Total 40ms
├─ parseJson                     Total 22ms
│  └─ Gson.fromJson              Total 18ms
├─ loadFromDb                    Total 13ms
│  └─ SQLite.query               Total 11ms
└─ bindViews                     Total  5ms

Self 是扣掉被调方之后自己代码花的时间,Children 是被调方花的,两者相加是 Total。于是 Top Down 展开出来是这样:

方法SelfChildrenTotal
onBindViewHolder0ms40ms40ms
parseJson4ms18ms22ms
Gson.fromJson18ms0ms18ms
loadFromDb2ms11ms13ms
SQLite.query11ms0ms11ms
bindViews5ms0ms5ms

Call Chart 会把这棵树按真实时间画出来:onBindViewHolder 是一条 40ms 的横条,下面三块按发生顺序排开,能看出 loadFromDb 是在 parseJson 之后才开始的。Flame Chart 丢掉时间,把相同调用路径的样本合到一起——假设这 40ms 在十次绑定里重复了十次,Gson.fromJson 那一格就攒到 180ms 宽,占整个记录的比例一眼可见,但你没法从图上说出它发生在第几帧。

Bottom Up 的口径最容易读错。展开 Gson.fromJson 看到 parseJson,这一行写的不是 parseJson 自己总共花了 22ms,而是「经由 parseJson 这条路径贡献给 Gson.fromJson 的时间」。所以同一方法在 Bottom Up 和 Top Down 里数字不同,不是工具算错,是两张表的统计主体根本不是同一个东西。

再叠一层 Wall clock time / Thread time:SQLite.query 那 11ms 里如果有 8ms 在等磁盘,Wall clock 记 11ms,Thread time 只记 3ms。九月那次掉帧,我后来把两次录制都切到 Thread time 又看了一遍,主线程自己真正占用 CPU 的部分小得可怜,等的部分才是全部故事。

案例一:一次列表掉帧,两次录制得出两个结论

先把当时的坏代码贴出来,为了能复现我把它简化过,包名换成代号:

// app/src/main/java/com/example/health/records/RecordAdapter.kt(改动前)
class RecordAdapter(
    private val dao: RecordDao,
    private val resolver: ContentResolver
) : ListAdapter<RecordRow, RecordVH>(Diff()) {

    override fun onBindViewHolder(holder: RecordVH, position: Int) {
        val row = getItem(position)
        // 每条都查一次本地库,还要跨进程拿一次配置
        val detail = runBlocking { dao.detailOf(row.id) }          // 主线程 + 挂起
        val unit = resolver.query(CONFIG_URI, null, null, null, null) // binder 跨进程
            ?.use { c -> if (c.moveToFirst()) c.getString(0) else "mg" }
        holder.title.text = row.title
        holder.value.text = "$detail $unit"
    }
}

第一次录制:Sample Java Methods,间隔默认,滚动十秒。

CPU 时间线        峰值 8.1%,均值 5.4%
主线程 Flame Chart
  android.os.MessageQueue.nativePollOnce          62.3%
  androidx.recyclerview.widget.RecyclerView...  18.7%
  com.example.health.records.RecordAdapter...    6.1%
  (其余为 framework / 渲染)
Top Down / 主线程 / doFrame
  Self 1.2ms   Children 6.8ms   Total 8.0ms

看上去完全没问题:主线程大半在 nativePollOnce,doFrame 才 8ms,远在 16.7ms 预算内。当时我就是拿这张图去群里下的结论。

第二次录制:换成 Trace System Calls,同一台机器、同一段滚动、同一份包。

Frames 轨道        10s 内 37 帧标红,最长 43.2ms,多数 20~35ms
主线程状态
  Running           合计 2.9s
  Runnable(等 CPU)  合计 1.1s
  Sleeping/等锁     合计 5.7s   ← 单段最长 87.4ms
binder_transaction
  content://com.example.health.config/unit      每帧 1 次,平均 21.6ms
SQLite / query
  SELECT * FROM record_detail WHERE id = ?      每帧 1 次,平均 9.3ms
Choreographer#doFrame
  最长 43.2ms(预期 ≤16.7ms)

差距全在第二次里。主线程不是不忙,是忙在等:等 binder 回包、等 SQLite、偶尔还被别的线程挤到 Runnable 排队。这些时间对 CPU 采样器来说等于「没在跑」,所以第一张图干净得不像有问题。

修的时候没动架构,只把两次查询从 onBind 里挪走:列表数据进页面时批量查一次放进内存,单位配置在 Application 里读一次缓存住,跨进程那次 binder 直接消掉。

// app/src/main/java/com/example/health/records/RecordAdapter.kt(改动后)
class RecordAdapter : ListAdapter<RecordRow, RecordVH>(Diff()) {

    // 由上层一次性把 detail 与 unit 拼进模型,onBind 只做赋值
    override fun onBindViewHolder(holder: RecordVH, position: Int) {
        val row = getItem(position)
        holder.title.text = row.title
        holder.value.text = row.displayValue
    }
}

// app/src/main/java/com/example/health/records/RecordVm.kt
class RecordVm(private val repo: RecordRepo) : ViewModel() {
    val rows = liveData {
        val unit = repo.unitOnce()              // 缓存,只读一次
        emit(repo.loadDetails().map { it.copy(displayValue = "${it.value} $unit") })
    }
}

同一套录法再跑一遍,Pixel 6 上标红帧从 37 降到 4,最长帧 43.2ms 降到 19.8ms;Redmi Note 11 上从 51 降到 9,最长 61.7ms 降到 24.1ms。CPU 采样那边的变化很小,峰值从 8.1% 变成 9.6%——主线程不睡了,反而多用了点 CPU。这个数如果只看第一张图,会以为改动让性能变差了。

想让业务代码在 System Trace 里露脸,得自己埋点,不然图上只有 framework 的 tag:

// app/src/main/java/com/example/health/trace/TraceSections.kt
object TraceSections {
    const val BIND = "M/RecordBind"
    const val LOAD = "M/RecordLoad"

    inline fun <T> section(name: String, block: () -> T): T {
        Trace.beginSection(name)          // 同一线程配对,finally 保证收口
        return try { block() } finally { Trace.endSection() }
    }
}

// 异步跨线程的场景用 cookie 配对的另一组
fun beginAsync(name: String, cookie: Int) = Trace.beginAsyncSection(name, cookie)
fun endAsync(name: String, cookie: Int) = Trace.endAsyncSection(name, cookie)

Trace.beginSection 和 endSection 必须在同一线程成对,beginAsyncSection / endAsyncSection 靠唯一 cookie 跨线程配对,别混用。埋完点,Trace System Calls 的时间线上就能直接看到 M/RecordBind 一段段贴着每一帧,比在几万行栈里翻类名快得多。

案例二:240ms 的接口解析,其实是探针自己

另一个坑来自插桩模式。有段时间「健康报告」页打开慢,我用 Trace Java Methods 录了完整的一次进入,Top Down 里 ReportParser.parse 明晃晃写着 240ms,Children 里一大片 Gson 反射调用。我拿着这个数去跟后端商量精简字段,折腾了两天没什么效果。

后来改成 Sample Java Methods 重录,同一个方法 31ms。差异不是环境波动,是插桩给每个方法入口出口都加了指令,而 parse 里全是短小的反射调用,探针开销被放大得最狠。插桩录出来的时间只能用来看调用关系和次数,不能当耗时读数——这条我吃过一次亏之后写进了组的检查清单。

修法是两档交叉:先用采样跑完整使用路径定大范围,再对一小段可疑代码用插桩确认调用链,最后回采样复测耗时。两种数据互相校验,比任何单次录制都靠谱。

命令行也能做同样的事,CI 里我用的是这一组:

# 采样录制,间隔 1000 微秒;操作完再 stop
adb shell am profile start --sampling 1000 /data/local/tmp/m_cpu.trace com.example.health
# ...在设备上复现那段交互...
adb shell am profile stop com.example.health
adb pull /data/local/tmp/m_cpu.trace ./captures/m_cpu.trace
# 拖进 Android Studio:Sessions 面板 → Start new profiler session → Load from file

导入的 .trace 在 CPU Profiler 里能正常看四种视图,但有两个例外官方文档写得很清楚:CPU 时间线上不显示 CPU 活动,线程 Activity 时间线只标出哪段有数据,不显示真实的运行 / 等待 / 休眠状态。想看线程状态,只能当场录 System Trace。

Memory Profiler:曲线、堆和引用链,是三件事

这个面板最容易被当成「看 Java Heap 那条线涨不涨」,其实一次完整的判断要用到三种互不等价的数据:实时的分类曲线、一段时间内的分配记录、某一瞬间的堆快照。

曲线是堆叠图,按类别分色:Java(Java / Kotlin 对象)、Native(C / C++ 分配)、Graphics(GL 表面、纹理这类图形缓冲队列,和 CPU 共享,不是 GPU 专用内存)、Stack(原生栈加 Java 栈,跟线程数相关)、Code(dex、编译产物、.so、字体)、Other(系统不知道往哪归的)。右轴上那条虚线是 Allocated,只数 Java / Kotlin 对象个数,不含 native 分配。曲线上每个小图标是一次 GC 事件。

这里有个我漏过很久的细节:Allocated 虚线剧烈起伏但 Java 曲线整体平,往往比「Java 曲线一路涨」更影响流畅度。它意味着大量短命对象在反复生成和回收,GC 被频繁触发,而 GC 暂停是要从 16.7ms 帧预算里扣的。

分配记录按系统版本分两套做法。Android 8.0(API 26)之后,直接在时间线上按住拖一段区域,下方就列出这段时间内分配的对象,能按 class / package / callstack 三种方式归组,点类名进 Instance View,点实例看 Call Stack,双击跳到代码。7.1 及以下得点工具栏的 Record memory allocations,而且最多记录 65535 条,超了只留最新的那批。AS 3.2 之后还能在下拉里切到 JNI heap,看 native 侧 JNI 引用的分配栈,同样要 API 26+。

堆快照是第三件事。点 Capture heap dump,等几秒,出来的是捕获那一瞬间所有存活对象加上它们之间的引用图。表格里几列各有各的意思:

列含义我拿它干什么
Allocations该类此刻存活的实例数先按这个降序,找多得不合理的
Shallow Size对象自身占的大小,不含它引用的对象判断这个类本身胖不胖
Native Size该对象引用的 native 对象大小Android 8.0 之后 Bitmap 像素在 native,这一列会突然很大
Retained Size删掉这个对象后能被一起回收的总大小判断「值不值得修」,比 Shallow 重要
Depth从 GC Root 到该实例的最短路径长度Depth 为 1 意味着直接被 GC Root 引用,基本不会自动回收

GC Root 是从堆外能访问到的对象——运行中的线程、局部变量、静态字段、系统服务里的注册引用都算。JVM 意义上的「泄漏」不是 C 语言那种指针丢了找不回来,而是再也不会用、却仍从 GC Root 可达。所以看引用链的时候,方向是从可疑实例往上追到最近的 GC Root,看看那条链断在哪儿最省事。

AS 3.6 之后 dump 完可以勾 Activity / Fragment Leaks,工具会按两条规则筛:一个已经 onDestroy 的 Activity 实例如果还被引用,报;一个 Fragment 没有关联任何 FragmentManager 却还被引用,报。第二条有已知的误报:dump 的时机刚好卡在 Fragment 已创建未 attach,或者 Fragment 被缓存还没复用,都会被标成泄漏。我第一次拿这个功能扫出一个「泄漏」,改了半天发现是 ViewPager 缓存的相邻页。

还有一个不太有人提的口径问题:Memory Profiler 自己也会往应用里注入对象做监控,大约每 10 万个对象最多虚增 10MB 的报告值。所以别拿 Profiler 里的绝对值去跟 dumpsys meminfo 的 PSS 对账,两者根本不是一套口径。要做跨工具比对,我用命令行 dump 的 HPROF:

adb shell am dumpheap -n -z /data/local/tmp/m_heap.hprof com.example.health
adb pull /data/local/tmp/m_heap.hprof ./captures/m_heap.hprof
# 需要时用 SDK 里的 hprof-conv 转格式再导入
hprof-conv ./captures/m_heap.hprof ./captures/m_heap_conv.hprof

案例三:四个退不掉的详情页,Retained Size 3.2MB

七月份有个灰度反馈,说进「报告详情」几次之后手机开始发烫、切换页面变慢。我打开 Memory Profiler,进出详情页五次,每次手动点一次强制 GC,Java 曲线没回落,稳稳往上抬了 12MB 左右。这不是 churn,是有东西真没被放掉。

拖完五次的区间看分配记录,ReportDetailActivity 的实例数停在 5,byte[] 和几个 Bitmap 相关的类也各是 5。抓一次堆 dump,勾上 Activity/Fragment Leaks,五个实例全被标出来,平均 Retained Size 3.2MB,Depth = 2。点开引用面板,链条很短:

GC Root (系统服务)
  └─ LocationManager.mListeners
       └─ ReportDetailActivity (implements LocationListener)
            ├─ mReportBitmap      (Bitmap,像素在 native)
            ├─ mPresenter
            └─ mDecorView / 整个 View 树

复现代码是这样的:

// app/src/main/java/com/example/health/report/ReportDetailActivity.kt(改动前)
class ReportDetailActivity : AppCompatActivity(), LocationListener {

    override fun onStart() {
        super.onStart()
        // 为了在报告上显示「记录地点」,把 Activity 自己注册进了系统服务
        val lm = getSystemService(LOCATION_SERVICE) as LocationManager
        lm.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 60_000L, 100f, this)
    }

    // onStop 里没有 removeUpdates,Activity 自己就是那个一直活着的 Listener
    override fun onLocationChanged(location: Location) { /* 更新界面 */ }
}

系统服务是常驻的 GC Root,mListeners 里攥着 Activity 的强引用,Activity 又攥着整个 View 树和那张报告图。只要没注销,GC 永远够不着它。这类泄漏用曲线也能猜到,但是 heap dump 的引用面板让我在两分钟内定位到 mListeners 这一行,而不是把详情页从头读一遍。

修法没引任何库,生命周期对称注销,顺手把位置监听换成 Application Context 持有的独立对象,界面要的数据通过回调传进来:

// app/src/main/java/com/example/health/report/ReportDetailActivity.kt(改动后)
class ReportDetailActivity : AppCompatActivity() {

    private val locationBus = LocationBus.get(applicationContext) // Application 级单例

    private val observer = object : LocationBus.Listener {
        override fun onChanged(place: String?) { binding.place.text = place ?: "" }
    }

    override fun onStart() {
        super.onStart()
        locationBus.add(observer)
    }

    override fun onStop() {
        locationBus.remove(observer)      // 对称注销,引用链断开
        super.onStop()
    }
}

改完重复同样五进五出、每次强制 GC,Java 曲线回到基线附近,dump 里 ReportDetailActivity 只剩 1 个实例,Retained Size 最大的那个从 3.2MB 掉到 41KB。Redmi Note 11 上连续进出二十次,GC 图标从 31 次降到 6 次。

顺带把 StrictMode 打开,这类 Activity 泄漏在开发期就会自己蹦出来,不用等 Profiler:

// app/src/main/java/com/example/health/DebugApp.kt
class DebugApp : Application() {
    override fun onCreate() {
        super.onCreate()
        if (BuildConfig.DEBUG) {
            StrictMode.setVmPolicy(
                VmPolicy.Builder()
                    .detectActivityLeaks()
                    .detectLeakedClosableObjects()
                    .penaltyLog()
                    .build()
            )
        }
    }
}

案例四:曲线平、虚线抖,掉帧却来自 GC

同月还有个更隐蔽的。列表加了实时刷新之后,滚动偶尔一顿,但 Memory Profiler 的 Java 曲线一直稳在 46MB 上下,我一开始排除了内存。

把时间轴放大到 2 秒区间才看出问题:Allocated 虚线在 12 万到 31 万之间来回锯,GC 图标密得几乎连成一条,几乎每 200ms 一次。拖那段范围看分配记录,String、StringBuilder、SimpleDateFormat 三类的实例数高得离谱——每帧都在把时间戳格式化一遍再拼成展示文案。

// app/src/main/java/com/example/health/records/TimeFmt.kt(改动前)
fun RecordRow.displayTime(): String {
    val sdf = SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.getDefault()) // 每帧新建
    return sdf.format(Date(timestamp)) + " · " + source + " · " + department
}

修成复用 formatter 加 StringBuilder 直接拼,去掉中间的临时字符串:

// app/src/main/java/com/example/health/records/TimeFmt.kt(改动后)
private val FORMAT = ThreadLocal.withInitial {
    SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.getDefault())
}

fun RecordRow.displayTime(): String = buildString(40) {
    append(FORMAT.get()!!.format(Date(timestamp)))
    append(" · ").append(source).append(" · ").append(department)
}

两段代码谁快谁慢,用 CPU 采样其实很难看出来——它们都是短方法,采样间隔一漏就什么都没有。真正有说服力的是 Memory Profiler 那条虚线:改之前 2 秒内分配了 190 万个对象、9 次 GC,改之后 23 万个、1 次 GC,同一段滚动的标红帧从 14 降到 2。这个案例我后来讲给组里,重点不是「别在循环里 new 对象」这种正确的废话,而是曲线平不等于没内存问题,Allocated 虚线和 GC 图标才是短命对象的证据。

native 那一半,得换个工具测

Memory Profiler 的堆叠图里有一截 Native,但曲线只告诉你「涨了」,不告诉你是哪条 native 调用栈拿着的。前面提过的 JNI heap 只能看 JNI 引用,要追到 native 分配本身,得换 Perfetto 的 heapprofd。

heapprofd 是 Android 10(API 29)加进来的进程外 native 堆分析器。它在 malloc / free(以及 C++ 的 new / delete)里做极少的采样 hook,默认按 4096 字节的间隔采一次调用栈,把栈复制进共享内存缓冲区,交给独立的 heapprofd 守护进程用 libunwindstack 异步展开和符号化,最后把账本写进 trace。采样率是精度和开销的交换阀:调大到 16384 字节开销更低,小分配就更容易漏;关掉时进程内几乎没有额外开销。数据落在 heap_profile_allocation、stack_profile_callsite、stack_profile_frame、stack_profile_symbol 这几张表里,可以用 SQL 查。

user 正式系统上,它只肯分析带 debuggable 或 profileable 标记的应用,否则采出来是一份空报告——这个前提让我白跑过一次,后面单独讲。Android 12 之后还能配 heaps: "com.android.art" 反过来采 Java 堆分配,但那和完整堆转储是两回事:采样看分配来源和趋势,堆转储才能追具体对象的引用链。

去年有个从图形组转过来的问题:报告页反复进出后,Memory Profiler 的 Java 曲线基本不动,Native 那一截缓慢上抬,每轮大概 1.8MB。用 heap dump 看不到任何可疑对象,因为像素和解码缓冲压根不在 Java 堆里。我改成采 heapprofd:

# 连续 dump:5 秒一个快照,把「总量」变成「斜率」
tools/heap_profile android -n com.example.health \
  -d 60000 -c 5000 --interval=4096 \
  -o /data/local/tmp/m_native_heap
adb pull /data/local/tmp/m_native_heap ./captures/native/
-- tools/native_outstanding.sql
SELECT
  sf.name                                   AS frame,
  SUM(a.size)                               AS outstanding_bytes,
  SUM(a.count)                              AS alloc_count
FROM heap_profile_allocation a
JOIN stack_profile_callsite c ON a.callsite_id = c.id
JOIN stack_profile_frame sf   ON c.frame_id = sf.id
WHERE a.size > 0
GROUP BY sf.name
ORDER BY outstanding_bytes DESC
LIMIT 20;
frame                                   outstanding_bytes  alloc_count
skia::Bitmap::tryAllocPixels             11_240_000         37
libjpegTurbo::decode                      3_880_000         37
android::Bitmap::allocateHeapBitmap       1_940_000         37
...

读这类报告有个坑:按「累计分配总量」排序会被高频的短命分配带偏,得盯**未释放(outstanding)**那一列,配合连续快照看它是不是随时间线性上抬。上面这份里 37 这个数字和进出次数一模一样,顺着栈回去查,是报告图的一块缓存没在 onStop 里释放,每进一次留一份。改成生命周期对称释放之后,60 秒内未释放量从 17MB 降到稳定在 2MB 左右,Native 曲线也不再一节节往上抬。

这个案例我特意留着,因为它说明一件事:同一个「内存涨了」,Java 堆、Native 堆、Graphics 三类要用三种不同的工具去看。只开一个 Memory Profiler 盯曲线,能发现异常,但定位不到代码行。

Network Profiler 到 Network Inspector:它只看得见标准 socket

这块工具的入口换过位置,很多老教程现在照着点会扑空。3.0 时代是在 Profiler 总览时间线上点 NETWORK 那一行;后来网络能力挪进了 App Inspection 下的 Network Inspector,Flamingo(2022.2.1)之后它默认把完整时间线的所有流量都铺出来,不再是选中一段才显示。名字变了、位置变了,底下那套取数方式没怎么变,所以先讲原理更省事。

它拦的是应用进程里标准 Java 网络栈的 socket 读写。IDE 在应用运行时注入一层 instrumentation,把 java.net 系(以及基于它工作的 OkHttp 等)的读写包住,于是能拿到每条连接的时间、上行下行字节、状态码、请求头、响应体,甚至把请求关联回发起它的线程和代码位置。HTTPS 也能看到解密后的内容,因为拦的位置在应用层、TLS 之下。

这个原理直接划出了它的边界:自己拿 native socket 走的协议、某些 WebSocket 长连接、走 TrafficStats 之外的通道,时间线上要么一片空、要么只有字节数没有请求详情。另外有个历史限制我一直记着——请求失败时不一定有对应信息显示,只看时间线会以为「没发请求」,实际是发出去没回来。所以线上报接口失败,我不会拿这个面板当证据,得回到日志或者抓包。

界面逻辑是三层。总览时间线上看到上行下行的峰值之后,拖选一段区间,下面出 Connection View(按文件列每条传输的 size / type / status / 时长)和 Thread View(按应用内线程列,看是哪条线程发的);选中某条再看 Request / Response 两个 tab。3.1 之前只有 Response,Request tab 是 3.1 补的,这件事本身就说明设计意图从「看响应大不大」转成了「看这次请求是怎么发出去的」。

拖选区间之后,Connection View 里每行那几个字段各有各的用法:Size 先按降序排,超大的响应体一眼可见;Type 能分出图片、JSON、二进制;Status 用来扫非 2xx;Time 那条横条是传输时长,配合 Thread View 看线程是否排队。我习惯先按 Size 扫一遍再按 Time 扫一遍,两次排序找出的往往不是同一批请求——大而不慢的是图片,慢而不大的是串行的小接口。

案例五:一个页面 47 条请求,全挤在同一条线程

八月中旬「健康计划」页加载慢,弱网下要四秒多才出内容。Network Profiler 的时间线像一排梳子齿,拖选那四秒,Connection View 里数出 47 条请求,其中 31 条是 3KB 以下的小包,状态码全是 200。

光看这个只能得出「请求多」。切到 Thread View,47 条全落在同一个 pool-3-thread-1 上,一条接一条排着,每条之间还留着 20~60ms 的空档——串行,且每条都要重新等一次 RTT。再看 Request tab,同一个 /plan/item 接口被调了 12 次,参数只有 id 不同。根因是列表项各自去拉自己的补充信息,而发起用的是一个单线程的 ExecutorService。

// app/src/main/java/com/example/health/plan/PlanRepo.kt(改动前)
private val io = Executors.newSingleThreadExecutor()   // 单线程,天然串行

fun loadPlan(ids: List<String>): List<PlanItem> = ids.map { id ->
    io.submit { get("/plan/item?id=$id") }.get()      // 每条都阻塞等一次网络
}

改动没引任何库:把单线程换成固定大小的线程池,N 条小请求合成一次批量接口,重复 id 先去重,结果塞进 LruCache。

// app/src/main/java/com/example/health/plan/PlanRepo.kt(改动后)
class PlanRepo(private val client: HttpStack) {

    private val io = Executors.newFixedThreadPool(4)
    private val cache = LruCache<String, PlanItem>(200)

    fun loadPlan(ids: List<String>): List<PlanItem> {
        val missing = ids.distinct().filter { cache[it] == null }
        if (missing.isNotEmpty()) {
            // 一次批量请求替掉 N 次单条请求
            val body = JSONObject().put("ids", JSONArray(missing)).toString()
            val resp = client.post("/plan/items/batch", body)
            parseItems(resp).forEach { cache.put(it.id, it) }
        }
        return ids.mapNotNull { cache[it] }
    }
}

同一台 Redmi Note 11、同一个弱网配置下复测:47 条降到 3 条,首屏内容出来从 4.1s 到 1.3s,Connection View 里那排梳子齿没了;Thread View 上四条线程各跑各的,不再排队。CPU Profiler 这边几乎没变化——优化的全是等待时间,这类收益在 CPU 采样上天然是隐形的,跟九月那次是同一个道理。

后来我把「切 Thread View」写成了组里的固定动作:Connection View 回答「发了多少」,Thread View 回答「是不是被自己排成了串行」,后者往往是弱网卡顿的真凶。

Energy Profiler 到 Power Profiler:估算和实测,差的不只是精度

这块是四代工具里原理变化最大的一处,也是我最想单独拎出来说的。

2018 年 3.2 加进来的 Energy Profiler,界面上是 Profiler 窗口底部新的一行,要 Android 8.0(API 26+)才出现。点开之后能看到估算能耗的柱状条,鼠标悬上去会拆成 CPU、网络、定位(GPS)三类资源的用量;下面还有一条 System 时间轴,专门标 wakelock、alarm、job 这些系统事件,选中某段时间,事件窗格里列详情,点某个 wakelock 能看它的调用栈,双击栈帧跳到发起它的代码。

关键词是估算。那根柱子不是电流表读出来的,是把应用的活动量套进一个模型折算成的相对值。它适合回答「我这次改动有没有让唤醒事件变多」「CPU 活动是不是比上一版更密」,不适合回答「这个版本省了多少电」。模型里没有屏幕、蜂窝射频状态机、厂商电源管理这些变量,拿它去跟系统设置里的耗电排行对账,怎么算都对不上。

2023 年 11 月 Hedgehog(2023.1.1)的 Power Profiler 换了数据源:从设备端电源轨监视器 ODPM 读真实功率,按 Power Rails 分成 power.rail.cpu.big、cpu.mid、cpu.little、gpu、wifi、display 这类子系统,数据挂在 System Trace 里,跟着同一条时间轴对齐应用内发生的操作。官方在发布说明里把差别写得很直白:旧的是用模型估算能耗,新的是设备上的功耗。Kuro Games 给《鸣潮》做优化时就是用这套加 A/B 测出 9.68% 的降幅,后来还拿 Perfetto Trace Processor 的 android_powerrails metric 自己算 30 秒 session 的 avg_used_power_mw 做版本对比。

门槛也实打实:要 Pixel 6 及以后、Android 10 以上,我那台 Redmi 上连这一行都不会出现。而且它读的是整机子系统的功率,不是「你的 App 用了多少电」——要归因,还得靠 trace 里的时间对齐,看某段操作期间哪条 rail 抬起来了。

案例六:把「CPU 能耗高」当成结论,白优化了一周

去年做列表图片加载改造时,旧 Energy Profiler 的柱子里 CPU 那一截明显最高,我据此判断解码吃电,花了一周把解码线程数、采样率、inSampleSize 挨个调,柱形没怎么动。

换 Pixel 6 上 Hedgehog 跑 Power Profiler,同一段滚动的电源轨读数是这样:

power.rail.cpu.big       avg 412.6 mW   占该段 13.1%
power.rail.cpu.little    avg 208.3 mW   占该段  6.6%
power.rail.gpu           avg 386.9 mW   占该段 12.3%
power.rail.wifi          avg 741.2 mW   占该段 23.6%   ← 最高
power.rail.display       avg 980.5 mW   占该段 31.2%

大头在 wifi 和屏幕,不在 CPU。回头翻 Network Profiler,列表滚动时每滑过一项就发一条图片请求,全是几 KB 的小包,射频被反复拉起来,尾能耗全记在无线那条 rail 上。最后真正有效的是把图片请求合并成批量预取、加一层磁盘缓存,而不是继续抠解码。

这个案例我复盘了挺久:旧面板没给错数据,它给的是「按模型折算,CPU 活动量占比高」;是我把「活动量占比」读成了「耗电占比」。换成实测之后才发现模型里最贵的那部分它压根没建模。

A/B 测电源轨我后来固定用这套流程,脱离 IDE 也能在 CI 里跑:

# 1) 用 Perfetto 配置采 30 秒,打开 android.power 数据源
adb shell perfetto -c - --txt -o /data/misc/perfetto-traces/power.perfetto-trace <<'CFG'
buffers: { size_kb: 63488 fill_policy: RING_BUFFER }
duration_ms: 30000
data_sources: {
  config {
    name: "android.power"
    android_power_config {
      battery_poll_ms: 1000
      collect_power_rails: true
    }
  }
}
data_sources: {
  config { name: "linux.ftrace"
    ftrace_config {
      ftrace_events: "sched/sched_switch"
      atrace_categories: "gfx"
      atrace_categories: "view"
      atrace_apps: "com.example.health"
    }
  }
}
CFG

adb pull /data/misc/perfetto-traces/power.perfetto-trace ./captures/
# tools/power_rails.py —— 用 Perfetto Trace Processor 取电源轨均值
import subprocess, json, sys

def rails(trace: str) -> dict:
    out = subprocess.check_output([
        "trace_processor_shell", "--query-stdout", trace,
    ], input=b"""
        SELECT name, AVG(value) AS avg_mw
        FROM counter c JOIN counter_track t ON c.track_id = t.id
        WHERE t.name LIKE 'power.rail%'
        GROUP BY name ORDER BY avg_mw DESC;
    """, text=True)
    rows = [ln.split(",") for ln in out.strip().splitlines()[1:] if ln.strip()]
    return {r[0]: round(float(r[1]), 1) for r in rows}

if __name__ == "__main__":
    print(json.dumps(rails(sys.argv[1]), ensure_ascii=False, indent=2))

两个版本、同一台机、同一段脚本操作、同样 30 秒、屏幕亮度固定,比的是 rail 均值而不是单次数值。单次读数受后台同步、网络状态影响太大,我吃过一次亏之后就再没拿单次数据下过结论。

Trace System Calls 与 Perfetto:把「等」画出来

开篇那次掉帧的完整定位,是在这个面板里做完的。它属于 CPU Profiler 的一种录制配置,但取数方式和前三种毫无关系:不抓 Java 栈,读的是内核 ftrace 的调度事件和 Framework 预埋的 atrace 埋点。

sequenceDiagram
    participant U as 用户手指
    participant C as Choreographer
    participant M as 主线程
    participant B as Binder 驱动
    participant S as SystemServer / ContentProvider
    participant R as RenderThread & GPU
    U->>C: 滑动输入 / VSYNC
    C->>M: doFrame 开始
    M->>B: query() 跨进程
    B->>S: binder_transaction
    Note over M: Runnable / Sleeping 87ms(CPU 采样看不到)
    S-->>B: 回包
    B-->>M: 返回 Cursor
    M->>M: measure / layout / draw 超时
    M->>R: 提交 RenderThread
    R-->>U: 超过 16.7ms,掉帧

采集链路是:内核 ftrace ring buffer 记 sched_switch、sched_wakeup、binder_transaction,Framework 用 atrace tag(gfx / view / am / wm / input / disk / sched / freq)往同一条时间线上写应用与系统事件;traced_probes 从 ftrace 和 /proc 取数,traced 守护进程管共享内存缓冲区和路由,序列化成 Protobuf 的 TracePacket 落文件。Android 10 之前是 systrace 的压缩文本 HTML,之后统一到这个格式,好处是能离线用 trace_processor 拿 SQL 查,而不是只能拿眼睛扫一张图。

面板上值得盯的轨道就那么几条:

  • Frames / FrameTimeline。Android 12(API 31)之后,配合 Chipmunk 及以上版本能看到更细的卡顿信息,把每帧的 Expected Timeline 和 Actual Timeline 分开画,还能给出 jank 的大类归属(是 App 侧超时、还是系统调度慢)。红帧不都赖自己,这条能省很多冤枉路。
  • 线程状态。Running / Runnable / Sleeping / Uninterruptible 四种颜色,长条的 Runnable 说明线程想跑但抢不到核,长条的等锁说明有人占着资源。九月那 87ms 就是一条 Sleeping 加一段 binder 等待。
  • CPU 各核。判断是不是被大核小核迁移、或者整机被别的进程占满。
  • binder / disk / 自定义 section。Trace.beginSection 埋的业务段会直接出现在图里,跟系统事件同一条时间轴,不用靠猜。

命令行采一份能存档、能进 CI 的 trace,我用的是这组:

adb shell perfetto -o /data/misc/perfetto-traces/scroll.perfetto-trace -t 10s \
  sched freq idle gfx view wm am ss binder_driver disk
adb pull /data/misc/perfetto-traces/scroll.perfetto-trace ./captures/scroll.perfetto-trace
# 拖进 ui.perfetto.dev,或直接用 Android Studio 打开

光看图还不够,批量回归得靠查。下面这段 SQL 我在 trace_processor_shell 里反复用,把超过一帧预算的 doFrame 和同期的 binder 阻塞一起捞出来:

-- tools/slow_frames.sql
SELECT
  s.name                         AS section,
  CAST(s.dur / 1e6 AS INT)       AS dur_ms,
  CAST(s.ts  / 1e6 AS INT)       AS start_ms,
  t.name                         AS thread
FROM slice s
JOIN thread_track tt ON s.track_id = tt.id
JOIN thread t        ON tt.utid = t.utid
WHERE s.name GLOB 'Choreographer#doFrame*'
  AND s.dur > 16670000
ORDER BY s.dur DESC
LIMIT 30;
section                     dur_ms  start_ms  thread
Choreographer#doFrame       43      4120      main
Choreographer#doFrame       35      4488      main
Choreographer#doFrame       31      4790      main
Choreographer#doFrame       28      5221      main
...

拿 start_ms 回 trace 里对齐同一时刻的 binder 与 SQLite slice,就能把「哪几帧慢」和「慢在等谁」对上。修复后重跑同一条 SQL,超过 16.7ms 的帧从 37 条降到 4 条,这是我能写进发版说明的数字,比看一眼火焰图说「好像顺了」扎实得多。

这里还有个常被忽略的能力:Trace.setCounter("M/pendingRequests", n) 能把一个数值随时间画成曲线,跟帧轨道叠在一起看。列表滚动时我埋了待处理请求数,一眼就能看出小包洪峰和红帧是不是同一时刻——比事后把两份日志拼起来方便太多。

Layout Inspector:它给结构,不给耗时

这个工具的历史比 Profiler 还长一截。3.1 那次更新把它接过了 Hierarchy Viewer 和 Pixel Perfect 的活:缩放和快捷键、参考网格叠加、加载设计稿当蒙版对比、把复杂布局里某个子树单独渲染出来预览。到 Arctic Fox 又多了 Layout Validation,一次性能在多种屏幕尺寸、字体大小、色彩校正模式下看同一套布局。

取数方式是 IDE 通过调试通道连到正在运行的进程,把 View 体系的 View 树连属性一起 dump 出一份快照;Compose 那侧读的是组合的语义树和 slot table,能显示每个节点的重组次数与跳过次数。因为是快照,界面上那一大棵树是某一刻的结构,不带任何时间信息——这是我见过最常被误用的地方:有人对着 Component Tree 说「这个布局慢」,可层级深只说明测量和布局可能更费,到底费不费得回 System Trace 里看 measure / layout / draw 那几段 slice 的实际时长。

它真正擅长回答的是三个问题:这层嵌套到底有几层、屏幕上某个像素对应哪个节点、Compose 的某个状态变化触发了多少次不必要的重组。

案例七:11 层嵌套,和一次滑动 300 多次重组

健康档案列表在 Redmi Note 11 上滑起来掉帧,System Trace 已经确认 measure + layout 段偏长,但看不出是哪块布局。打开 Layout Inspector 抓一帧快照,Component Tree 里一个列表项从 FrameLayout 根到最里面的 TextView 数出 11 层,其中三层是只包了一个子 View 的 LinearLayout,还有一层是历史遗留的 CardView 套 MaterialCardView。

<!-- app/src/main/res/layout/item_record.xml(改动前,节选) -->
<FrameLayout ...>
  <LinearLayout ... android:orientation="vertical">
    <LinearLayout ...>              <!-- 只包一个子 View -->
      <androidx.cardview.widget.CardView ...>
        <LinearLayout ... android:orientation="horizontal">
          <LinearLayout ...>        <!-- 又只包一个子 View -->
            <TextView android:id="@+id/title" ... />
            <TextView android:id="@+id/value" ... />
          </LinearLayout>
        </LinearLayout>
      </androidx.cardview.widget.CardView>
    </LinearLayout>
  </LinearLayout>
</FrameLayout>

改成一层 ConstraintLayout 拉平,两个 TextView 用约束横向排,去掉多余容器:

<!-- app/src/main/res/layout/item_record.xml(改动后) -->
<androidx.constraintlayout.widget.ConstraintLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <TextView android:id="@+id/title"
        android:layout_width="0dp" android:layout_height="wrap_content"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toStartOf="@id/value"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintHorizontal_weight="1" />

    <TextView android:id="@+id/value"
        android:layout_width="wrap_content" android:layout_height="wrap_content"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

System Trace 里同一段滚动,measure + layout 合计从每帧 4.8ms 降到 1.9ms。Layout Inspector 自己不产出这个数字,它只负责把「11 层」这个事实摆到眼前。

Compose 那一半是另一个坑。同一个列表迁到 Compose 之后,Layout Inspector 的重组计数显示:一次轻微滑动,列表里可见的 12 个 item 累计重组 318 次,其中大部分节点标着「skipped 0」。顺着节点找到根源——我把整个 RecordRow 对象当参数传进每个 item,而这个类是普通 data class,里面有个 List<String> 字段,编译器判定它不稳定,于是父级任何一次状态变化都让所有 item 跟着重组。

// app/src/main/java/com/example/health/records/RecordList.kt(改动前)
@Composable
fun RecordItem(row: RecordRow) {          // RecordRow 含 List<String>,不稳定
    Text(row.title)
    Text(row.displayValue)
}

改法是把 composable 的参数收敛到稳定的基本类型,让跳过判断能生效;列表给 key,列表项数据用 @Immutable 标注并保证真的不可变:

// app/src/main/java/com/example/health/records/RecordList.kt(改动后)
@Immutable
data class RecordRow(
    val id: String,
    val title: String,
    val displayValue: String,
    val tags: List<String>          // 只在构造时赋值,之后不再改动
)

@Composable
fun RecordItem(
    title: String,                  // 基本类型,稳定性可判定
    value: String,
    onOpen: (String) -> Unit
) {
    Text(title)
    Text(value)
}

@Composable
fun RecordList(rows: List<RecordRow>, onOpen: (String) -> Unit) {
    LazyColumn {
        items(rows, key = { it.id }) { row ->
            RecordItem(row.title, row.displayValue, onOpen)
        }
    }
}

同一段滑动,重组计数从 318 降到 47,跳过的节点明显多了起来。这里我没引任何额外依赖,@Immutable、稳定类型、key 都是 Compose 自己提供的东西。

用这个面板有两个前提别忘了:应用得是可调试的,Compose 重组计数在 release 包上拿不到;快照是静态的,任何关于「多快」的结论都得换个工具验证。

App Inspection:数据库和后台任务,终于能当场看

Arctic Fox(2020.3.1)把一批「检查器」收进了 App Inspection 这个统一入口,其中跟性能最相关的是 Database Inspector 和 Background Task Inspector。

Database Inspector 挂在应用的 SQLite 连接上,进程活着的时候能实时看库里的表、字段和数据变化,还能直接跑 SQL。它的价值不在「看数据」,在验证写入时机:一条同步到底有没有落库、是不是每帧都在写、事务有没有被合并。Background Task Inspector 要求 WorkManager 2.5.0+ 且设备 API 26+,把任务队列、状态流转、执行与取消画成列表,用来回答「后台到底排了多少活」。

案例八:退出页面后还在转圈,队列里躺着 11 个一样的 Worker

十月初有个反馈:进「数据同步」页再退出,通知栏的进度条还在,偶尔重复上传。Profiler 的 CPU、内存、网络三条线上都看不出明显异常,因为每次任务都很轻,只是次数多。

打开 Background Task Inspector,任务列表里同一时刻排着 11 个 SyncWorker,全是 Enqueued,隔一会儿有一个变 Running,跑完又补一个进来。翻调用点:

// app/src/main/java/com/example/health/sync/SyncPage.kt(改动前)
override fun onStop() {
    super.onStop()
    val req = OneTimeWorkRequestBuilder<SyncWorker>()
        .setConstraints(
            Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build()
        ).build()
    // 每次都用 APPEND,退出一次就往队尾再挂一个
    WorkManager.getInstance(this).enqueueUniqueWork(
        "health_sync", ExistingWorkPolicy.APPEND, req
    )
}

APPEND 会把新任务挂到同名链尾部,页面反复进出就攒出一长串。这不是「代码写错了」那么简单——如果只看单次执行,每个 Worker 都正常,问题出在队列的形状上,而队列形状只有这个面板能一眼看到。

改成只保留一个、带上必要约束,并且在页面创建时用 KEEP 避免重复替换正在跑的任务:

// app/src/main/java/com/example/health/sync/SyncPage.kt(改动后)
private fun scheduleSync(context: Context) {
    val req = OneTimeWorkRequestBuilder<SyncWorker>()
        .setConstraints(
            Constraints.Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .setRequiresBatteryNotLow(true)
                .build()
        ).build()
    WorkManager.getInstance(context).enqueueUniqueWork(
        "health_sync", ExistingWorkPolicy.KEEP, req
    )
}

复测进出十次,队列里始终只有 1 个 SyncWorker,通知栏不再重复。Database Inspector 那边顺手确认了同步结果的写入次数:改动前一小时内 sync_log 表多了 43 行,改动后 4 行,和 Background Task Inspector 上的任务数对得上。

这类问题的共同点是:单次执行都健康,病在调度结构里。CPU Profiler 看的是每条任务内部,看不到队列;只有把「队列」当成一个对象去看,才可能发现 11 这个数字不对劲。

两个面板都有硬前提:Database Inspector 只覆盖应用通过标准 SQLite / Room 打开的库,加密库或者 native 直连的看不到;Background Task Inspector 的版本门槛不满足时,界面上干脆没有这个 tab,我第一次在 API 25 的测试机上找了二十分钟才想起来查版本要求。

可调试、profileable 与 Sessions:把证据留下来

这一节本来应该放在最前面,因为不少人测出来的数从一开始就不准,却把后面所有分析都建在它上面。

我以前图省事,性能分析一律跑 debug 包。直到有次同一段滚动,debug 包录出的 doFrame P90 是 31ms,灰度包用线上埋点报回来只有 19ms,差了六成。查到最后不是代码差异,是 debuggable 本身:官方文档在 <profileable> 那一页写得很直白——可调试的应用会带来各种明显的性能下降,不适合用来精确衡量时间。调试器挂钩、额外的检查、不同的编译优化,全都会掺进读数里。

正确做法是在 release / 生产构建上声明这个 manifest 元素:

<!-- app/src/main/AndroidManifest.xml -->
<manifest ...>
    <application ...>
        <!-- API 29 引入;让本地分析工具能读调用栈,不开放内存数据 -->
        <profileable android:shell="true" />
    </application>
</manifest>

<profileable> 引入于 API 29(Android 10),android:shell="true" 允许 android.os.Trace 跟踪 API、simpleperf、am profile 以及 perfetto 的原生内存 / Java 内存 / CPU 分析器在发布版上工作;android:enabled 是 API 30 新增的,默认 true,设成 false 就完全禁止任何性能分析。它带来的数据泄露风险很小:主机工具和 shell 进程读不到内存内容,只能读栈,而发布版的栈通常已经被混淆或本来就缺符号。

最后那半句有个实际后果:release 包采出来的 native 栈经常是一堆混淆过的类名或者光秃秃的地址,得把对应版本的 mapping 和带符号的 .so 一起归档才看得懂。我现在每次出性能报告都顺手把 mapping.txt 和符号目录塞进同一次采集的文件夹里,否则三个月后回看那份 trace 等于白采。

核对合并后的 manifest 到底生效没有,用这条:

adb shell dumpsys package com.example.health | grep -iE 'profileable|debuggable'
#   flags=[ ... DEBUGGABLE ... ]     <-- debug 包,测时间不可信
#   profileableFromShell=true        <-- release 包声明生效(字段随版本与厂商变化)

光看 dumpsys 字段还不够保险,我一般会再跑一次 5 秒的短会话,确认 perfetto 真能拿到数据,然后才开始正式采集。

再说 Sessions。3.2 起 IDE 会把 Profiler 数据自动存成会话,可以在一次 IDE 运行期间随时回去看;方法跟踪记录、堆转储、网络活动都挂在同一个会话下面,能在多次录制之间来回切换比对,还能导入导出给别人。导出的产物按类型分清楚,别混:

产物由谁产出里面是什么能拿它做什么
.traceCPU Profiler / Debug.startMethodTracingJava 方法调用栈与时间四种视图、导入 IDE 离线看
.hprofMemory Profiler / am dumpheap某一刻的存活对象与引用图引用链、Retained Size、泄漏检查
.perfetto-traceSystem Trace / perfetto 命令行内核事件、atrace、帧、电源轨、heapprofdPerfetto UI、SQL 查询、CI 门禁

导入 .trace 有两个官方写明的例外:CPU 时间线上不显示 CPU 活动,线程 Activity 时间线只标出哪段有数据、不还原真实的运行 / 等待 / 休眠状态。所以「把 trace 存档回头再分析线程状态」这条路是走不通的,要看状态必须当场录 System Trace。.perfetto-trace 没这个限制,它本来就是可查询的结构化数据,我现在做归档一律以它为主。

一次排查我最后留下的目录长这样,别人拿着能原样复现:

captures/20260903_scroll/
├── scroll.perfetto-trace        # 主证据:帧、线程状态、binder
├── m_cpu.trace                  # 采样录制,离线看四种视图
├── heap.hprof                   # 五进五出后的堆快照
├── build-info.json              # 机型、系统版本、构建号、commit、冷/温态
├── mapping.txt                  # 该版本混淆映射
└── notes.md                     # 先写下的预测,以及哪条被数据否定了
{
  "device": "Pixel 6 / Redmi Note 11",
  "os": "Android 13 / Android 11",
  "build": "8.2.2-agp, compileSdk 34, minSdk 24",
  "commit": "9f3c1a7",
  "state": "cold, force-stop before each run",
  "script": "tools/capture_scroll.sh",
  "metrics": ["jank_frames_10s", "doFrame_p90", "activity_instances", "first_screen_requests"],
  "samples": 10
}

notes.md 里那份「先写下的预测」是我最看重的。三个月后回看一份 trace,光有数据没有当时的问题定义,很容易被新结论带着走,把当初已经否定过的假设又捡回来。

从会点按钮到会造证据

四代工具用下来,我越来越觉得「提升使用能力」这件事,跟记住多少个菜单项关系不大。工具每往前走一代,对人的要求就换一层,把这几层拆开看,比刷一堆快捷键有用。

flowchart LR
  A[L1 会点<br/>知道每个面板的入口和读数] --> B[L2 会问<br/>把「卡」翻成可证伪的假设]
  B --> C[L3 会造<br/>造出稳定可复现的场景]
  C --> D[L4 会钉<br/>把判读规则写进 SQL 与 CI]
  D --> E[回到 L2<br/>下一轮拿新问题重新问]
  A -. DDMS 时代够用 .-> A
  B -. 3.0 统一时间轴之后 .-> B
  C -. 3.2 起能给归因 .-> C
  D -. Perfetto 可查询之后 .-> D

L1 是认得读数,知道 Sample Java 的 8% 是采样占比、Retained Size 是删掉后能回收的总量、Energy 那根柱子是估算值。这一层靠文档和一次上手就能补,也是大部分人停下来的地方。

L2 是把现象翻成假设。九月那次我栽在这儿:拿到「滑动卡顿」直接开了 CPU Profiler,等于默认假设了「CPU 忙」。现在我会在动手前先写两句预测,写在便签上:

假设 A:主线程自己算得慢 → CPU 采样应出现宽的绿色业务栈;
                          System Trace 里 Running 长条、doFrame 超时。
假设 B:主线程在等 I/O  → CPU 采样应很低、nativePollOnce 占比高;
                          System Trace 里 Sleeping / binder / disk 长条。
假设 C:GC 抖动          → Memory 的 Allocated 虚线锯齿、GC 图标密集。

录完逐条对。哪条预测没应验,就说明我对这个系统的理解有洞,而不是「工具没测出来」。

「先写预测再录」这招是从那 8% 学来的。它逼你把模糊的「卡」拆成互斥的、能被数据否定的几条,也顺带解决了「七个面板全开然后被信息淹没」的问题——你只需要开能区分 A/B/C 的那两三个。

L3 是造得出稳定场景。同一台机同一版本,冷态和热态、亮度、网络、后台同步、数据条数、操作路径,任何一项不固定,录十次能出十个样。我现在的采集脚本会把这些写死:

#!/usr/bin/env bash
# tools/capture_scroll.sh —— 固定场景,避免「这次又不一样」
set -euo pipefail
PKG=com.example.health
OUT=./captures/$(date +%Y%m%d_%H%M)

adb shell am force-stop "$PKG"                 # 统一冷态
adb shell settings put system screen_brightness 120
adb shell cmd connectivity airplane-mode enable >/dev/null 2>&1 || true
adb shell dumpsys battery set level 80
mkdir -p "$OUT"

adb shell perfetto -o /data/misc/perfetto-traces/s.perfetto-trace -t 12s \
  sched freq idle gfx view wm am ss binder_driver disk &
sleep 1
adb shell am start -n "$PKG/.records.RecordListActivity" >/dev/null
# 固定十次等距滑动,别用手
for i in $(seq 1 10); do
  adb shell input swipe 540 1600 540 500 120
  sleep 0.8
done
wait
adb pull /data/misc/perfetto-traces/s.perfetto-trace "$OUT/scroll.perfetto-trace"
adb shell am dumpheap -n -z /data/local/tmp/h.hprof "$PKG"
adb pull /data/local/tmp/h.hprof "$OUT/heap.hprof"
echo "$OUT"

L4 是把判读钉进流程。Perfetto 把 trace 变成能查的数据之后,判读规则终于可以离开人眼:doFrame > 16.7ms 的帧数、binder 等待总时长、Allocated 峰值、任务队列长度,都能写成 SQL 或脚本,作为发版前的门禁。IDE 自己也在往这走——2025 年 I/O 上,Android Studio 里的 Agent 能激活 Perfetto trace analysis,自己下载 trace processor 去查 trace 验证「启动为什么慢」,而不是给一句笼统建议;LeakCanary 被内嵌进 IDE,检出泄漏旁边直接给修复入口。工具的下一站是替你做第一轮假设验证,人的位置就更要往 L2 挪:会提问、会设计能证伪的判据、会判断 AI 给的结论有没有被数据支持。

四层不是学完一层丢一层。我给自己定的四个数,每一轮都要按 L2 写预测、按 L3 固定场景、按 L4 出可比的数字:

数口径样本优化前优化后
标红帧数System Trace Frames 轨道,10s 固定脚本滚动Pixel 6 / Redmi Note 11 各 10 轮37 / 514 / 9
最长帧 P90trace_processor 查 doFrame 超时帧的时长分位同上38.4ms / 54.1ms18.2ms / 22.6ms
Activity 存活实例heap dump,五进五出且每次强制 GCRedmi Note 11,5 轮51
首屏请求数Network Thread View,弱网配置同上473

四个数都不是「平均值」,卡顿这类问题看平均值几乎没有意义——最慢的那几帧才决定用户感受。样本量、机型、态、路径都写在口径里,换人复测才对得上。

一次完整排查,七个面板的前后顺序

分面板讲完,再把它串成一条线。十月二十号有个工单:「首页第二次打开,偶尔白一下」。同一套动作我带着组里一个新同事走了一遍,顺序不是随手开的,每一步都在缩小下一轮的候选集。

1) 先写预测(写在 notes.md,不打开任何工具)
   A 主线程算得慢 → CPU 采样应有宽的绿色业务栈
   B 在等 I/O    → CPU 采样应低,System Trace 应有 binder / disk 长条
   C GC 抖动     → Allocated 虚线锯齿、GC 图标密集
   D 数据结构没准备好 → 请求串行、任务队列重复

2) 固定场景:force-stop 造冷态、亮度 120、固定网络配置、脚本点十次
3) 开 Trace System Calls(先排除 B,因为它能同时看帧和等待)
   结果:第二次打开有 3 帧标红,主线程有一段 62ms Sleeping
   → A 基本被否定,B 嫌疑最大
4) 开 Sample Java Methods 交叉验证
   结果:CPU 峰值 7.9%,业务栈很窄
   → 确认不是算力问题
5) 开 Memory Profiler 曲线(不是堆 dump)
   结果:Allocated 虚线平稳,GC 图标 2 次
   → C 否定
6) 开 Network Inspector,切 Thread View
   结果:9 条请求排在一条线程上,其中 4 条是重复的配置接口
   → D 成立一半,但 62ms 的等待比 9 条请求的总时长短,还有别的
7) 回 System Trace,按红帧时间对齐
   结果:62ms 那段是一次 binder 跨进程读配置,恰好落在首帧之前
8) 开 App Inspection / Background Task Inspector
   结果:同一时刻有 3 个相同的配置同步 Worker 排队
9) Layout Inspector 只做最后确认:首屏层级 6 层,重组计数正常
   → 结构不是瓶颈,不用动布局

修复是把配置读一次缓存住、把 3 个重复 Worker 收敛成 1 个 KEEP,没动任何布局代码。复测十轮,标红帧从 3 降到 0,最长帧 47.6ms 降到 14.2ms。

这一趟里最有用的不是第七步找到 binder,是第三步就先否掉了 A。如果按常见习惯从 CPU Profiler 开始,看到 7.9% 大概会得出「不是 CPU」然后转向内存,绕一大圈。先开能同时区分多个假设的面板,再开只能确认单一假设的面板,顺序反了成本会翻倍。

七个面板全开不会有更多结论,只会多出六份看不完的图。我现在一次排查平均只开三到四个,剩下的都是用来「确认不是」的,而确认不是也必须有数据,不能靠感觉跳过。

面板速查:拿到现象,先决定开哪一个

七个面板写下来信息有点多,我把它压成一张查表用的东西。左边是拿到的现象,右边是第一个该开的面板和它的盲区——盲区那一列比入口那一列重要。

现象先开看什么这个面板看不见
滑动掉帧、CPU 却很低Trace System Calls线程状态、binder / disk、Frames 轨道具体 Java 方法热点
某个方法到底多慢Sample Java MethodsFlame Chart 宽度、Top Down 的 Self短方法、等待时间
一次操作究竟调了谁Trace Java MethodsCall Chart、调用次数(不看耗时)真实耗时,探针会拖慢
native / JNI 侧热点Sample C/C++ Functionsnative 采样栈(要符号表)Java 层调用关系
内存一路涨、回不来Memory Profiler 堆 dump引用链、Retained Size、Depth曲线趋势、GC 频率
内存平但偶发卡顿Memory Profiler 曲线Allocated 虚线、GC 图标密度是谁在分配(要拖区间看分配记录)
弱网加载慢Network Inspector Thread View请求数、是否串行、单条大小失败请求、非标准 socket
后台一直在动Energy / Power + App Inspectionwakelock / job 事件、任务队列形状单次任务内部耗时
层级深、重组多Layout InspectorComponent Tree、重组计数任何耗时数值
改动前后到底有没有变好Perfetto SQL + 固定脚本同一口径下的分位数单次读数的偶然波动

版本门槛,和「本地测准了、线上却对不上」

各章散着提的设备和版本要求,先汇到一处。这张表我贴在采集脚本的注释里,每次换机器先扫一遍,省得像当年那样对着 API 25 的测试机找二十分钟 Energy 面板。

功能最低要求不满足时的表现
Energy Profiler(旧,估算)AS 3.2 + 设备 API 26Profiler 窗口底部没有 Energy 那一行
Trace System Calls设备 API 24录制配置里选不到 / 采不出线程状态
Sample C/C++ Functions设备 API 26 + 带符号表栈是一串地址
JNI heap 分配检查AS 3.2 + 设备 API 26分配记录下拉里没有 JNI heap
Memory 分配记录直接拖时间线设备 API 26得点 Record,且上限 65535 条
导入 .trace 离线看AS 3.2无 CPU 活动、无线程状态还原
Activity / Fragment 泄漏自动检查AS 3.6dump 里没有那个勾选框
<profileable>API 29(android:enabled 为 API 30)release 包采不到,或采出空报告
heapprofdAndroid 10 / API 29无 native 调用栈数据
heapprofd 采 Java 堆分配Android 12 / API 31heaps: "com.android.art" 不生效
Perfetto 平台追踪Android 10 / API 29回落到 systrace 格式
FrameTimeline 细粒度卡顿信息设备 API 31 + 较新 AS只有红帧,没有 jank 分类
Power Profiler / ODPMHedgehog 2023.1.1 + Pixel 6 之后、Android 10+没有 Power Rails,只有旧估算
Background Task InspectorWorkManager 2.5.0+ 且设备 API 26App Inspection 里没有这个 tab
Compose 重组计数可调试构建release 包拿不到计数
Network Inspector 全时间线流量Flamingo 2022.2.1 之后得手动拖选区间

比门槛更难处理的是口径。九月那次之后我陆续攒了几个「本地好看、线上照样被吐槽」的场景,原因都不在代码:

测的包不对。 debug 包有 debuggable 开销,前面说过;反过来,release 包被 R8 优化、内联、类名改掉之后,方法栈和耗时分布跟 debug 包也不是一回事。性能报告里我会同时记下包名、构建类型和 commit,不然两组数没法比。

态不对。 冷态要 force-stop 造,温态、热态各有各的样子;同一段滚动,第一次进页面和第三次进页面差距能有几十毫秒。前面那个 capture_scroll.sh 里固定 force-stop 就是为了把这件事锁死。

机器不对。 模拟器跑 CPU、GPU、磁盘 I/O 的调度跟真机完全是两套,尤其在 x86 镜像上,native 侧的结论几乎不能外推。性能数字一律以真机为准,模拟器只用来确认功能路径。

口径不对。 Profiler 的 Frames 轨道看的是 Choreographer / FrameTimeline 那条线,平台 OnFrameMetricsAvailableListener 给的 TOTAL_DURATION 是另一套计时范围,线上埋点量的「从点击到首屏内容可见」又是第三种。三个数对不上是常态,硬凑到一张表里比不写还糟。我给线上埋点单独写了一个基于平台 API 的采集器,只用来看分布,不拿来和 trace 里的毫秒数直接相减:

// app/src/main/java/com/example/health/perf/FrameMetricsCollector.kt
class FrameMetricsCollector(
    private val activity: Activity,
    private val onReport: (total: Int, jank: Int, p90Ms: Long) -> Unit
) {
    private val durations = ArrayList<Long>(600)
    private val handler = Handler(Looper.getMainLooper())
    private var jank = 0

    private val listener = Window.OnFrameMetricsAvailableListener { _, metrics, _ ->
        val ns = metrics.getMetric(FrameMetrics.TOTAL_DURATION)
        val ms = TimeUnit.NANOSECONDS.toMillis(ns)
        durations.add(ms)
        if (ms > 17) jank++                       // 60Hz 的粗略门槛,按实际刷新率调整
        if (durations.size >= 600) flush()
    }

    fun start() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            activity.window.addOnFrameMetricsAvailableListener(listener, handler)
        }
    }

    fun stop() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            activity.window.removeOnFrameMetricsAvailableListener(listener)
        }
        flush()
    }

    private fun flush() {
        if (durations.isEmpty()) return
        val sorted = durations.sorted()
        val p90 = sorted[(sorted.size * 0.9).toInt().coerceAtMost(sorted.lastIndex)]
        onReport(sorted.size, jank, p90)
        durations.clear()
        jank = 0
    }
}

OnFrameMetricsAvailableListener 是 API 24 的平台能力,不需要额外依赖;FrameMetrics 还能取 DRAW_DURATION、LAYOUT_MEASURE_DURATION 等分项,用来判断慢在绘制还是在测量。这套数据我只按 P50 / P90 / P99 上报分布,绝不拿平均值当结论——最慢那批帧才决定用户嘴里的「卡」。

把这一层接上之后,闭环才算完整:线上分位数告诉你「有没有问题、影响多少人」,本地 Profiler 告诉你「为什么」,CI 里的 SQL 门禁保证「别再回来」。三个环节各用各的尺子,谁也别替谁。

让 AI 读 trace:四段我实际在用的提示词

工具迭代到 2025 年这一站,IDE 里的 Agent 已经开始自己调 Perfetto trace analysis 查数据了。我平时用 Trae 做同一件事,但有个前提一直没松:AI 负责把数据整理成可核对的证据,不负责替我下结论。它编一个数比人快得多,所以每段提示词里都写了「不许出现 trace 里没有的数字」。

项目里先放一份忽略规则,免得几十兆的 trace 和 heap dump 混进上下文:

# .traeignore
captures/
**/*.perfetto-trace
**/*.trace
**/*.hprof
**/*.hprof.conv
build/
.gradle/

模式上踩过一次版本坑:2026 年 5 月之后 SOLO Builder 和 SOLO Coder 合并成了 SOLO Agent,旧教程里「先出计划等确认、再切 Builder 执行」的两段式写法已经找不到入口了。下面四段都按一次投喂、自带证据和验收来写。

第一段 · 对着 trace 做归因,不许先给答案

角色与边界:
你是 Android 性能分析助手。只根据我提供的文件说话,不做代码修改。
trace 里没有的数字一律不许出现,缺证据就写「数据不足」。

目标:
判断这次列表滑动掉帧的主因,并把结论拆成「假设 → 支持/否定的证据 → 残留疑问」。

上下文:
@docs/metrics.md
@captures/20260903/scroll.perfetto-trace
@tools/slow_frames.sql
@docs/version-facts.md

任务:
1) 先列出 4 条互斥假设:主线程计算、等 I/O 或等锁、GC 抖动、系统调度慢。
2) 用 trace_processor 跑 slow_frames.sql,把超时帧的 start_ms 与 dur_ms 列成表。
3) 对每个 start_ms 前后 100ms,查同期的 binder_transaction、disk、SQLite、
   GC 相关 slice 与线程状态,逐条标注它支持或否定哪条假设。
4) 输出一张「假设 | 证据 | 结论」表,最后单列一段「还缺什么数据才能定论」。

约束:
- 不写「可能是」「一般来说」这种不落地的措辞,每条判断都要能指到某个 slice。
- 不许把 CPU 采样占比低直接等同于「不是 CPU 问题」,这条我错过一次。
- 不许改动任何源码,本轮只产 docs/trace-attribution.md。

验收:
结论表里每一行的证据都能用 trace_processor 的某条 SQL 复现;
我人工跑 tools/slow_frames.sql 核对帧数与你写的一致。

第一版它给的是「主线程存在较多耗时操作,建议优化布局」,典型的笼统话。打回之后我加了第 1 条和第 3 条,逼它先把假设摆出来再用 slice 逐条打勾,输出才变成能核对的表。顺带挑出一件我自己没注意的事:37 个红帧里有 6 个发生在 binder 之外,是 GC 造成的,跟后来案例四那条虚线对上了。

第二段 · 把判读规则钉成门禁

角色与边界:
只新增 CI 相关文件,不动业务代码。

目标:
把「掉帧回归」变成一条能卡住发版的规则,规则要能被人读懂、也能被脚本执行。

上下文:
@docs/metrics.md
@tools/slow_frames.sql
@tools/capture_scroll.sh
@captures/20260903/scroll.perfetto-trace

任务:
1) 定义三个可度量数:10s 内超时帧数、doFrame 时长 P90、最长帧时长。
   每个数写清口径、采样方式、机型、样本量、阈值来源。
2) 写 tools/check_frames.py,读 trace_processor 的查询输出,
   任一数超阈值就 exit 1,并打印一行人能看懂的原因。
3) 写 .github/workframes.yml,调 capture_scroll.sh 再调 check_frames.py,
   把 trace 与查询结果作为 artifact 上传。
4) 阈值先按现有基线给,不许凭空写一个「业界标准」。

约束:
- 不许用平均值做门禁,用分位数。
- 脚本找不到 trace 或查询无结果时 exit 1,不许静默 exit 0。
- 零第三方依赖,Python 只用标准库。

验收:
我拿优化前的 trace 跑一遍必须失败,拿优化后的跑一遍必须通过;
故意把 trace 改名再跑,也要失败。

exit 0 那条是吃过亏加上的:最早一版脚本在找不到输入文件时静默成功,门禁挂了两个月等于没挂。现在这三条验收我每次都真跑一遍,不信任脚本自称通过。

第三段 · 读引用链,别让它碰二进制

角色与边界:
只分析我贴出来的文本,不要尝试读取 .hprof 二进制文件。

目标:
判断下面这条 heap dump 引用链里,最短的修复点在哪一层。

上下文:
@captures/20260712/heap.txt        (Memory Profiler 引用面板导出的纯文本)
@docs/metrics.md

任务:
1) 把引用链从 GC Root 到目标实例逐层列出,标出每一层是系统持有还是应用持有。
2) 找出应用侧第一个能主动断开的引用点,给出对应的生命周期方法。
3) 说明为什么断这一层能让 Retained Size 一起降下来。
4) 列出 2 个可能的误报场景(例如 Fragment 缓存、创建与 attach 之间)。

约束:
- 不引第三方检测库,修复建议只用平台 API 或 AndroidX。
- 权限相关的建议里,申请权限前先弹用途说明。
- 不许编造类名、实例数、Size 数值,heap.txt 里没有就写「未提供」。

验收:
我按你给的那层引用去代码里搜,能在 5 分钟内定位到具体一行;
改完重复五进五出、每次强制 GC,实例数回到 1。

第四段 · 换身份挑自己的刺

角色与边界:
你现在是发版前的复核人,任务是推翻我下面的结论,不是附和。

上下文:
@docs/trace-attribution.md
@docs/metrics.md
@captures/20260903/
@tools/check_frames.py

任务:
1) 列出结论里所有没有直接数据支撑的推断,逐条标注「证据不足」或「口径错误」。
2) 检查四个数的口径:机型、系统版本、冷/温/热态、样本量、分位数算法
   是否前后一致,有没有把两次不同条件的读数放在一张表里比。
3) 扮演一个只拿到这份文档、没有参与排查的同事,
   写出他最可能提出的 5 个质疑,并给出补哪份数据才能回答。
4) 单列一段「我这次最可能搞错的是哪件事」。

约束:
- 不许用「整体来看」「基本合理」这种和稀泥的话。
- 每条质疑要指到具体文件与具体行,不指文件就别写。

验收:
如果 5 个质疑里有 2 个以上我答不上来,这版归因就不进发版说明。

这四段不是流水线,是我按「判读 → 固化 → 归因 → 复核」四个动作分开用的。最后一段最值钱:它挑出过「我把 Pixel 6 的 P90 和 Redmi 的最长帧放在同一行做对比」这种口径混用,那张表我本来都准备贴进周报了。

AI 能替做的,是把几万行 trace、几百条引用链压缩成一张能对账的表;替不了的,是决定该问哪个问题、以及哪个数值得钉进 CI。工具这四代一路把人从「看现象」推到这里,接下来要练的其实还是 L2 那层。

踩过的坑,按当时看到的报错排

前前后后攒下来的,按现象归了一下。同一场翻车经常同时踩中好几条。

现象根因修复
CPU 8% 但明显掉帧在等 binder / SQLite,等待时间不进 CPU 样本换 Trace System Calls 看线程状态
插桩录出 240ms,采样只有 31ms全量插桩把短方法拖慢数倍插桩只看调用关系,耗时回采样复测
nativePollOnce 铺满火焰图主线程大部分时间在休眠等消息,不是它自己慢看它等在谁身上,别优化 nativePollOnce
短方法在采样里完全找不到执行时间短于采样间隔调小间隔,或改用插桩确认调用链
火焰图横轴对不上真实时间Flame Chart 横轴是相对执行时间占比要看时序切 Call Chart
Top Down 和 Bottom Up 同名方法数字不一致两者时间口径基于不同节点按问法选一个,别交叉相加
进程 CPU 里有个陌生线程一直占着Studio:Perfa / JDWP / Profile Saver 等 IDE 注入线程按名字排除,别算进业务账
录到一半数据不再增长老设备撞到录制文件大小上限,静默停收集API 26+ 无此限制,或缩短录制分段录
导入的 .trace 看不到线程状态离线导入只标出哪段有数据,不还原状态状态只能当场录 System Trace
Profiler 里找不到 Energy 那一行3.2 的 Energy 要 API 26+换 Android 8.0 以上设备
拿 Energy 柱子当 mA·h 报给产品那是模型折算的相对估算值说明口径;要实测换 Power Profiler + ODPM
Redmi 上找不到 Power RailsODPM 需 Pixel 6+ / Android 10+换支持机型,或退回事件级分析
电源轨显示整机而非单 App读的是子系统功率用 trace 时间对齐做归因
单次电源轨读数和上次差一倍后台同步、亮度、网络状态没固定固定场景、多轮取均值做 A/B
Energy 里 wakelock 点开看不到调用栈没在事件窗格里选中具体事件选中事件再看 Call Stack,双击跳代码
内存曲线一路涨,强制 GC 也不回落Activity 被系统服务里的 Listener 强引用生命周期对称注销,别让 Activity 当 Listener
heap dump 报 Fragment 泄漏,代码没问题dump 卡在已创建未 attach,或 ViewPager 缓存换时机重 dump,或查缓存策略
Java 曲线平,却一直掉帧短命对象 churn 导致 GC 密集盯 Allocated 虚线和 GC 图标,复用对象
Profiler 内存值比 dumpsys meminfo 大 10MB分析工具自身注入对象的虚增别拿两者对账,跨工具比对用命令行 HPROF
7.1 上分配记录少了一大截老版本最多记 65535 条分配缩短录制区间,或换 API 26+ 设备
Bitmap 的 Shallow Size 很小8.0 起像素在 native,看 Native Size按 Retained / Native Size 判断
Network 时间线一片空,日志明明发了请求请求失败不显示,或走了非标准 socket回日志 / 抓包,别拿时间线当失败证据
Network 只显示流量没有请求详情native socket、自定义协议不在拦截范围用别的通道验证
找不到 NETWORK 那一行新版本入口挪到 App Inspection 的 Network Inspector从 View → Tool Windows → App Inspection 进
47 条请求全串行单线程 ExecutorService 加逐条阻塞 get()批量接口 + 固定线程池 + 缓存
Layout Inspector 上说「布局慢」它只给结构快照,不给耗时回 System Trace 看 measure/layout slice
release 包看不到 Compose 重组计数重组计数要可调试构建用 debug 包抓,别拿 release 下结论
层级 11 层改成 2 层却没快多少瓶颈其实在 draw 或数据准备先用 trace 分段确认再动布局
Background Task Inspector 没有这个 tabWorkManager 需 2.5.0+ 且设备 API 26+升库或换设备
退出页面后队列越攒越长ExistingWorkPolicy.APPEND 每次追加同名链改 KEEP / REPLACE,收紧约束
Database Inspector 看不到某个库加密库或 native 直连不覆盖换可调试的标准 Room / SQLite 连接
同一份代码测十次十个结果冷热态、亮度、网络、数据规模没固定用 capture_scroll.sh 固定场景
CI 门禁一直绿,其实脚本没跑找不到 trace 时静默 exit 0输入缺失一律 exit 1,故意改名验证
AI 给的归因里冒出一个没见过的类提示词没禁编造加「数据不足就写数据不足」和逐条对账验收

命令速查

按用途分了四组,输出片段只留该看的那几行。

# --- CPU:采样录制、导入 ---
adb shell am profile start --sampling 1000 /data/local/tmp/m_cpu.trace com.example.health
adb shell am profile stop com.example.health
adb pull /data/local/tmp/m_cpu.trace ./captures/m_cpu.trace

# --- 内存:堆快照 ---
adb shell am dumpheap -n -z /data/local/tmp/m_heap.hprof com.example.health
adb pull /data/local/tmp/m_heap.hprof ./captures/
hprof-conv ./captures/m_heap.hprof ./captures/m_heap_conv.hprof

# --- 内存:PSS 分项,跟 Profiler 的分类曲线不是一套口径 ---
adb shell dumpsys meminfo com.example.health
#   TOTAL PSS:  148320 KB     <-- 系统算账看这个
#   Java Heap:   46080 KB
#   Native Heap: 21844 KB
#   Graphics:    38912 KB
# --- System Trace / Perfetto ---
adb shell perfetto -o /data/misc/perfetto-traces/s.perfetto-trace -t 10s \
  sched freq idle gfx view wm am ss binder_driver disk
adb pull /data/misc/perfetto-traces/s.perfetto-trace ./captures/

# 长时间录制用配置文件,RING_BUFFER 防止撑爆内存
adb shell perfetto -c - --txt -o /data/misc/perfetto-traces/long.perfetto-trace \
  < tools/long_trace.pbtx

# 查看设备支持的追踪类别
adb shell atrace --list_categories | head -30
#   gfx - Graphics
#   view - View System
#   am  - Activity Manager
#   binder_driver - Binder Kernel driver
# --- trace_processor:把图变成能查的数 ---
trace_processor_shell --query-stdout ./captures/s.perfetto-trace \
  < tools/slow_frames.sql
# section                   dur_ms  start_ms  thread
# Choreographer#doFrame     43      4120      main

# 电源轨均值(需采过 android.power)
trace_processor_shell --query-stdout ./captures/power.perfetto-trace <<'SQL'
SELECT name, AVG(value) AS avg_mw FROM counter c
JOIN counter_track t ON c.track_id = t.id
WHERE t.name LIKE 'power.rail%' GROUP BY name ORDER BY avg_mw DESC;
SQL
# --- 场景固定与状态确认 ---
adb shell am force-stop com.example.health       # 统一冷态
adb shell dumpsys deviceidle force-idle          # 需要省电场景时
adb shell dumpsys jobscheduler | grep -A3 com.example.health
adb shell dumpsys usagestats | grep -i bucket
adb shell settings put system screen_brightness 120
# 固定滑动,别用手,十次等距
for i in $(seq 1 10); do adb shell input swipe 540 1600 540 500 120; sleep 0.8; done

dumpsys meminfo 那几行我最常提醒自己:它是 PSS 口径,按比例分摊了 Zygote 共享页,跟 Memory Profiler 堆叠图里那个「Java」不是一个东西,两边的数字对不上是正常的。

还能往下挖的地方

按我自己排的投入产出比,从最值得做的往下:

方向解决什么代价
把四个数接进 CI 并留 trace artifact性能回归不靠人记,发版前自动挡一道要维护脚本和基线,门槛本身会漂移
用 Trace.setCounter 把业务指标叠到帧轨道一眼看出请求洪峰 / 缓存命中与红帧是否同时埋点要克制,加多了自己干扰 trace
FrameTimeline 的 jank 分类逐条啃分清 App 侧超时与系统调度慢,少背锅也少漏要 API 31+ 设备,低版本覆盖不到
写一套自己的 Perfetto SQL 查询库常见归因从「看图找」变成「跑一条」得熟悉 slice / track / counter 表结构
OnFrameMetricsAvailableListener 做线上分位数IDE 里看不到的真实用户分布要设计采样与上报,别把埋点做成新负担
heapprofd 查 native 侧分配Java 堆正常但 PSS 涨时的另一半账需要带符号表的 so,采样开销要评估
电源轨 A/B 做成常规回归把「估算能耗」彻底替成实测对比只有部分 Pixel 支持,设备得固定
simpleperf 补 native 热点端侧推理 / 音视频场景 Java 采样够不着符号表与 NDK 工具链要配齐
把 Layout Inspector 的重组计数纳入 Code Review不稳定参数导致全列表重组这类问题前置拦截得先让组里对「稳定类型」有共识
让 AI 跑第一轮假设验证,人只复核几万行 trace 的初筛时间压到分钟级结论必须可复现,否则比不查更危险

前三项我现在已经在做,第四项做了一半。最后一项我留了个心眼:AI 给的表一定得能用 SQL 复现,复现不了的一律不进文档,这条规矩比它给出的结论值钱。

后来

十月底整理 captures/ 目录,翻到九月三号那份 m_cpu.trace,8.1% 那条曲线还在。我把它和同一天的 scroll.perfetto-trace 放在一个文件夹里,改名为「别只看第一张图」。

那台 Redmi Note 11 现在还在工位抽屉里,屏幕亮度被我锁在 120,跑固定脚本用。同事偶尔借去测别的东西,还回来时亮度总被改掉,我就再设一次。