【Android 性能优化实战 60 讲】07 手写 BlockCanary 核心原理:Looper 监听 + 栈转储,打造主线程卡顿监控

3 阅读8分钟

【Android 性能优化实战 60 讲】07 手写 BlockCanary 核心原理:Looper 监听 + 栈转储,打造主线程卡顿监控

专栏合集:《Android 性能优化实战 60 讲:大厂 ANR 治理手册与 120Hz 流畅度揭秘》 本文是专栏第 07 讲。上一篇我们用 GPU 呈现模式实现了卡顿的快速肉眼定性,但它只能线下使用、只能判断大类,无法线上自动化监控,也无法定位具体代码行。本篇我们就手写一套主线程卡顿监控核心——BlockCanary,从原理到代码彻底搞懂大厂 APM 的基石能力。

前言:为什么大厂都有自己的主线程监控

做性能优化,线下定位问题只是第一步,更重要的是线上大规模用户的卡顿监控。Systrace 需要连电脑、GPU 呈现模式只能肉眼看,都无法线上批量部署。而线上用户反馈「卡顿」,你总不能让每个用户都抓 Trace 吧?

业界的标准方案,就是应用层主线程卡顿监控:在用户手机上实时监控主线程每一个消息的处理耗时,超过阈值就自动保存现场堆栈、CPU、内存等信息,上报到后台。这就是 BlockCanary 的核心价值,也是所有大厂 APM 系统的标配基石。

很多人用过 BlockCanary 库,但很少有人深究原理。其实它的核心机制非常巧妙——完全基于 Android 系统原生的 Looper 机制,不需要 Native 层、不需要 Hook,纯 Java/Kotlin 就能实现。

本篇我们会从「主线程卡顿的本质」讲起,拆解 Looper Printer 监听机制,对标系统 ANR 的 SIGQUIT 栈转储原理,最后手写一个完整可运行的简化版 BlockCanary。

一、主线程卡顿的本质:Looper 消息循环

要理解监控原理,先得理解卡顿的本质。Android 主线程的所有操作——点击事件、布局绘制、页面跳转、接口回调——本质上都是一个个 Message,交由 Looper 循环串行处理。

1.1 Looper.loop() 的核心循环

主线程启动时会调用 Looper.loop(),进入无限循环:

java

public static void loop() {
    final Looper me = myLooper();
    final MessageQueue queue = me.mQueue;
    // ...
    for (;;) {
        Message msg = queue.next(); // 可能阻塞
        // ...
        // 【关键】消息分发前打印
        final Printer logging = me.mLogging;
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target + " " +
                    msg.callback + ": " + msg.what);
        }
        // ...
        msg.target.dispatchMessage(msg); // 处理消息
        // ...
        // 【关键】消息分发后打印
        if (logging != null) {
            logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
        }
        // ...
    }
}

核心逻辑非常简单:

  1. 从消息队列取下一条消息;
  2. 分发前:如果设置了 Printer,打印「开始标记」;
  3. 执行 dispatchMessage 处理消息;
  4. 分发后:打印「结束标记」。

1.2 卡顿的定义

单条消息的 dispatchMessage 执行时间,就是这条消息占用主线程的时间。如果这个时间超过了卡顿阈值(通常 50ms 以上用户就会有感知),用户就会感觉到卡顿。

关键洞察:只要能监控每一条消息的开始时间和结束时间,就能计算出耗时,判断是否卡顿。而系统刚好留下了 Looper.setMessageLogging() 这个口子——我们可以注入自己的 Printer,监听每一条消息的开始与结束。

二、BlockCanary 两大核心基石

BlockCanary 的整个实现,就是围绕两个核心机制展开的:消息分发监听 + 超时栈转储。前者负责「发现卡顿」,后者负责「定位卡顿」。

2.1 基石一:Looper.setMessageLogging 消息监听

这是整个方案的基础。通过 Looper.getMainLooper().setMessageLogging(printer),我们可以注入自定义的 Printer,接管每一条消息的开始与结束事件。

标记格式约定

系统打印的开始和结束标记有固定格式:

  • 开始:>>>>> Dispatching to Handler (android.os.Handler) {xxx} android.view.View$PerformClick@xxx: 0
  • 结束:<<<<< Finished to Handler (android.os.Handler) {xxx} null

我们只需要在 println 方法中:

  1. 以 >>>>> 开头 → 记录开始时间、消息信息;
  2. 以 <<<<< 开头 → 计算耗时,判断是否超时。
为什么这是合法的?

很多人担心这是黑科技,其实不是。setMessageLogging 是 Android 官方公开的 API,设计初衷就是用于调试和日志打印。它稳定、兼容所有版本,不需要任何反射或 Hook。

2.2 基石二:超时栈转储(对标系统 SIGQUIT 机制)

光知道卡顿了还不够,必须知道卡在哪行代码。这里就要对标系统 ANR 的处理机制。

系统 ANR 的 SIGQUIT 原理

当系统检测到应用无响应(ANR)时,会向应用进程发送 SIGQUIT 信号,触发进程自动 dump 所有线程的堆栈到 /data/anr/traces.txt,供开发者分析。这是系统级的「卡顿现场保留」。

应用层的「SIGQUIT」

BlockCanary 在应用层模拟了这个机制:当检测到消息耗时超过阈值时,主动 dump 主线程的调用堆栈,相当于在卡顿发生的那一刻按下「暂停键」,把现场保存下来。

堆栈获取用系统原生 API 即可:

kotlin

val stackTraces = Thread.getAllStackTraces()
val mainThreadStack = stackTraces[Looper.getMainLooper().thread]

两者的区别:系统 SIGQUIT 是进程级的全线程 dump,由系统触发;BlockCanary 是应用层的主线程 dump,由我们自己的超时逻辑触发。核心目的都是保留卡顿现场的调用栈。

2.3 完整工作流程

  1. 初始化:向主线程 Looper 设置自定义 Printer,配置卡顿阈值(默认 500ms);
  2. 消息开始:Printer 收到 >>>>> 标记,记录当前时间戳、消息信息;
  3. 消息结束:Printer 收到 <<<<< 标记,计算耗时;
  4. 超时判定:耗时 < 阈值 → 正常,清理现场;耗时 ≥ 阈值 → 触发卡顿采集;
  5. 现场采集:dump 主线程堆栈、采集 CPU 使用率、内存占用、当前页面等信息;
  6. 日志输出:保存到本地文件,或上报到监控后台。

三、实战:手写简化版 BlockCanary

我们用 Kotlin 手写一个最小可用版本,包含核心的监听、判定、栈转储能力。

3.1 卡顿信息实体

首先定义卡顿信息的数据结构:

kotlin

data class BlockInfo(
    val blockTimeMs: Long,      // 卡顿耗时
    val thresholdMs: Long,      // 触发阈值
    val threadStack: String,    // 主线程堆栈
    val timeStamp: Long = System.currentTimeMillis()
)

3.2 卡顿监听器接口

kotlin

interface OnBlockListener {
    fun onBlock(blockInfo: BlockInfo)
}

3.3 核心监控实现

kotlin

object SimpleBlockCanary {

    private var isStarted = false
    private var thresholdMs = 500L // 默认卡顿阈值500ms
    private var listener: OnBlockListener? = null

    // 消息开始时间
    @Volatile
    private var dispatchStartTime = 0L
    @Volatile
    private var currentMessage: String? = null

    /**
     * 启动卡顿监控
     */
    fun start(threshold: Long = 500L, blockListener: OnBlockListener) {
        if (isStarted) return
        thresholdMs = threshold
        listener = blockListener

        // 向主线程Looper注入自定义Printer
        Looper.getMainLooper().setMessageLogging { message ->
            dispatchMessage(message)
        }
        isStarted = true
    }

    /**
     * 处理Printer的每一条打印
     */
    private fun dispatchMessage(message: String) {
        // 过滤掉非消息分发的日志
        if (!message.startsWith(">>>>>") && !message.startsWith("<<<<<")) {
            return
        }

        if (message.startsWith(">>>>>")) {
            // 消息分发开始
            dispatchStartTime = System.currentTimeMillis()
            currentMessage = message
        } else if (message.startsWith("<<<<<")) {
            // 消息分发结束
            val cost = System.currentTimeMillis() - dispatchStartTime
            if (cost >= thresholdMs) {
                // 触发卡顿
                notifyBlocked(cost)
            }
        }
    }

    /**
     * 触发卡顿回调,采集堆栈
     */
    private fun notifyBlocked(costMs: Long) {
        val stack = dumpMainThreadStack()
        val blockInfo = BlockInfo(
            blockTimeMs = costMs,
            thresholdMs = thresholdMs,
            threadStack = stack
        )
        // 切到子线程执行,避免在Printer中做耗时操作
        Thread {
            listener?.onBlock(blockInfo)
        }.start()
    }

    /**
     * dump主线程堆栈
     */
    private fun dumpMainThreadStack(): String {
        val mainThread = Looper.getMainLooper().thread
        val stackElements = mainThread.stackTrace
        return buildString {
            append("主线程堆栈:\n")
            stackElements.forEach { element ->
                append("\tat $element\n")
            }
        }
    }

    /**
     * 停止监控
     */
    fun stop() {
        if (!isStarted) return
        Looper.getMainLooper().setMessageLogging(null)
        isStarted = false
        listener = null
    }
}

3.4 使用方式

在 Application 中初始化:

kotlin

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        // 仅在Debug/测试环境开启
        if (BuildConfig.DEBUG) {
            SimpleBlockCanary.start(threshold = 300L) { blockInfo ->
                // 这里可以打印日志、保存文件或上报
                Log.w("BlockCanary", "检测到主线程卡顿:${blockInfo.blockTimeMs}ms")
                Log.w("BlockCanary", blockInfo.threadStack)
            }
        }
    }
}

这样,只要主线程任何一条消息处理超过 300ms,就会自动打印卡顿堆栈,直接定位到具体的类和方法。

四、大厂级增强能力

上面的简化版已经具备核心能力,但大厂的自研 APM 还会做很多增强,提升监控的准确性和信息丰富度。

4.1 信息增强:不止于堆栈

真正的卡顿现场,需要完整的上下文信息,才能快速复现和定位:

信息类型作用获取方式
CPU 使用率判断是应用自己慢还是系统 CPU 繁忙读取 /proc/stat 和 /proc/[pid]/stat
内存占用判断是否内存不足导致卡顿ActivityManager.getMemoryInfo()
前后台状态区分前台交互卡顿还是后台任务卡顿注册 ActivityLifecycleCallbacks 统计
当前页面定位在哪个页面发生的卡顿记录顶层 Activity 名称
消息队列状态看是单条消息慢还是队列堆积反射获取 MessageQueue 待处理消息数

4.2 采样优化:避免漏检长卡顿

简化版有一个明显的缺陷:只有消息结束时才知道卡顿。如果一条消息阻塞了 3 秒,我们要等 3 秒后消息结束才能 dump 堆栈——这时候卡顿现场可能已经过去了,dump 到的是结束时的栈,不是最卡那一刻的栈。

大厂的解决方案是超时预采样:

  1. 消息开始时,启动一个延时任务(比如阈值 500ms,就延时 500ms 执行);
  2. 如果 500ms 内消息结束了,就取消延时任务;
  3. 如果 500ms 后消息还没结束,说明已经卡顿了,立即 dump 第一次堆栈;
  4. 之后每隔一定时间(比如 200ms)再 dump 一次,直到消息结束。

这样就能捕捉到卡顿过程中的多个时间点的堆栈,更精准地定位阻塞点。

4.3 性能开销控制

监控本身不能造成新的卡顿,所以开销控制非常重要:

  • 正常路径极轻量:只做时间记录和字符串判断,都是纳秒级操作;
  • 只在超限时才 dump 栈:堆栈采集是相对耗时的操作,正常流程绝对不执行;
  • 动态阈值:前台交互场景阈值高(500ms),后台场景阈值低(200ms);
  • 采样率控制:线上全量开启时,可以按比例采样(比如 10% 用户),避免日志量爆炸。

五、能力边界与局限

BlockCanary 不是万能的,它有明确的适用边界,知道它不能做什么和知道它能做什么同样重要。

✅ 能做的

  • 监控主线程所有 Message 的处理耗时
  • 定位主线程 Java 层的卡顿堆栈
  • 线上大规模部署,批量采集卡顿数据
  • 轻量、无侵入、兼容性好

❌ 不能做的

  • 无法监控 Native 层卡顿:Native 代码阻塞主线程,堆栈可能停留在 Native 方法,看不到具体原因;
  • 无法监控 RenderThread 卡顿:渲染线程的卡顿不占用主线程消息时间,Printer 监控不到;
  • 看不到消息内部的函数耗时分布:只能知道整个消息慢,不知道里面哪个函数最慢(需要结合 Systrace 或插桩);
  • Printer 冲突:如果多个库都调用 setMessageLogging,后面的会覆盖前面的。

最佳实践:BlockCanary 做线上监控发现问题,Systrace 做线下精准定位根因,两者配合使用。

六、5 个常见避坑误区

❌ 误区 1:阈值设置越低越好

阈值设成 16ms,想监控每一次掉帧,结果会产生海量误报。系统调度本身就有波动,主线程偶尔 20-30ms 是正常的。

建议:普通交互场景 300-500ms,列表滑动场景 100-200ms,根据业务场景配置。

❌ 误区 2:在 Printer 里做耗时操作

println 方法是在主线程执行的!如果你在里面写日志、做 IO,反而会造成主线程卡顿。

原则:Printer 里只做最轻量的记录,耗时操作全部扔到后台线程。

❌ 误区 3:只 dump 一次堆栈就够了

长卡顿的过程中,堆栈可能是变化的。只 dump 一次很可能抓到的是收尾阶段的栈,不是真正的阻塞点。

建议:超时后周期性采样,保留多帧堆栈。

❌ 误区 4:用卡顿数量直接衡量性能

不同页面、不同操作的消息数量不一样。不能只看卡顿次数,要看卡顿率 = 卡顿消息数 / 总消息数,或者单位时间卡顿时长。

❌ 误区 5:线上全量开启详细日志

详细堆栈 + 环境信息,单条卡顿日志可能几十 KB,全量开启会导致用户流量和存储压力很大。

建议:线上采用「采样 + 聚合」策略,只上报统计数据,严重卡顿才上报详细堆栈。

七、实战练习

  1. 将本文的 SimpleBlockCanary 代码复制到你的项目中;
  2. 在 Application.onCreate() 中启动监控;
  3. 在某个 Activity 中故意制造一个卡顿(如 Thread.sleep(2000));
  4. 观察 Logcat 中是否输出了卡顿日志和堆栈信息;
  5. 根据堆栈信息定位到具体代码行;
  6. 尝试调整阈值和采样间隔,观察不同配置下的效果。

八、下讲预告

第 08 讲我们将进入字节码插桩领域,带来 Matrix 无痕埋点插件化原理:

  • 剖析微信 Matrix-Trace 的 Transform 插桩机制;
  • 理解编译期字节码插桩如何实现全局方法耗时统计;
  • 对比「手动埋点」与「无痕埋点」的优劣与适用场景。