如何确定应用发生了卡顿?

根据前面的文章我们知道Choreographer.doFrame()方法必须要在16.67ms以内完成才不会导致应用丢帧,因此如果一个Choreographer.doFrame()执行时间超过了16.67ms则可以认为应用发生了卡顿,那么如何确定Choreographer.doFrame()的执行时间呢？

计算 Choreographer.doFrame() 的执行时间

其实Choreographer提供了一个API:postFrameCallback():

Choreographer.getInstance().postFrameCallback(object :Choreographer.FrameCallback{
    override fun doFrame(frameTimeNanos: Long) {
    
    }
})

这个Callback会在Choreographer.doFrame()中回调。

上面doFrame(frameTimeNanos: Long)的frameTimeNanos参数的含义是: 这一帧真正开始执行的时间点, 所以我们可以通过计算两个Choreographer.FrameCallback的时间间隔来推断出 Choreographer.doFrame()到底执行了多长时间, 大概代码如下:

Choreographer.getInstance().postFrameCallback(object :Choreographer.FrameCallback{
    override fun doFrame(frameTimeNanos: Long) {
        if (mLastFrameTimeNanos != 0L) {
            val diffFrameCoast = (frameTimeNanos - mLastFrameTimeNanos) //计算一个doFrame消耗的时间
            mFrameListeners.forEach {
                it.doFrame(diffFrameCoast)
            }
        }
        mLastFrameTimeNanos = frameTimeNanos
        Choreographer.getInstance().postFrameCallback(this)
    }
})

即上面不断循环调用Choreographer.getInstance().postFrameCallback(this)(这样会导致Choreographer不断请求Vsync信号来回调Choreographer.doFrame()方法), 并计算出doFrame方法的执行时间，然后通知给观察者。

捕获卡顿

上面我们已经拿到了Choreographer.doFrame()的执行时间，那么我们只需要定义一个卡顿阈值就就可以判断是否产生了卡顿:

class RabbitBlockMonitor : ChoreographerFrameUpdateMonitor.FrameUpdateListener {

    val blockThreshold = 16666666 * 10

    override fun doFrame(frameCostNs: Long) {

        if (frameCostNs > blockThreshold) {
            toastInThread("检测到卡顿!!")
        }
    }
}

上面我简单的把卡顿的检测阈值定为10帧(10 * 16.67)。

如何捕获卡顿发生时的堆栈？

其实对于堆栈的获取主要有两个问题:

获取主线程的堆栈可能会导致主线程卡顿
获取某个时间点的堆栈只是该时刻的一个堆栈快照, 那么如何在卡顿发生时，获取到前面卡顿时的堆栈呢?

对于上面第一个问题我们可以在子线程中获取主线程的堆栈。, 不过要在当前时刻获取过去时刻的堆栈就比较困难了。这里我们采用另一个方法 : 周期性的采集主线程堆栈

周期性的采集主线程堆栈

我们可以每隔16.67ms在异步线程获取一下主线程的堆栈然后保存起来，在卡顿发生时，把这些周期性采集的堆栈当做卡顿时的堆栈。这种方法可以抓住大部分卡顿现场,不过也会获取一些无用的堆栈信息。

下面来看一下具体实现方法:

class RabbitBlockMonitor : ChoreographerFrameUpdateMonitor.FrameUpdateListener {

    private var stackCollectHandler: Handler? = null
    private var blockStackTraces = HashMap<String, RabbitBlockStackTraceInfo>()

    private val blockStackCollectTask = object : Runnable {
        override fun run() {
            val stackTrace =  RabbitBlockStackTraceInfo(getUiThreadStackTrace())
            val mapKey = stackTrace.getMapKey()
            val info = blockStackTraces[mapKey]
            blockStackTraces[mapKey] = if (info == null) stackTrace else info.collectCount++
            stackCollectHandler?.postDelayed(this,stackCollectPeriod)
        }
    }

    init {
        val sampleThread = HandlerThread("rabbit_block_monitor")
        sampleThread.start()
        stackCollectHandler = Handler(sampleThread.looper)
    }

    override fun doFrame(frameCostNs: Long) {

        stackCollectHandler?.removeCallbacks(blockStackCollectTask)

        if (frameCostNs > blockThreshold && blockStackTraces.isNotEmpty()) {
            ...保存卡顿堆栈信息
        }

        stackCollectHandler?.postDelayed(blockStackCollectTask, stackCollectPeriod)
        blockStackTraces.clear()
    }
}

先理一下上面代码的主要逻辑:

在Choreographer.doFrame()回调中通过Handler向HandlerThread发送一个消息。
在HandlerThread中采集主线程的堆栈并保存在map中(避免采集重复的堆栈信息)
以固定的堆栈采集周期向HandlerThread继续发送堆栈采集的消息
当Choreographer.doFrame()的frameCostNs超过了卡顿阈值时，就把在frameCostNs这个时间内采集到的堆栈作为卡顿现场

需要注意的是，上面代码在frameCostNs < stackCollectPeriod时是不会去采集主线程的堆栈的。

其实堆栈采集的原理大致如下:

即上面如果卡顿了200ms的话，那么会采集11次堆栈。

综上大致叙述了应用卡顿监控的原理,还有一些细节点本文就不叙述了，想了解的话可以看Rabbit的实现。

最终捕获的卡顿堆栈现场大约是下面这样:

Rabbit是我最近在实战的一个性能监控的项目，后面我会更新更多性能监控相关文章。欢迎关注我的微信公众号: