六、分析工具

工具对比

使用指南

需要分析Native代码，选Simpleperf
需要分析系统调用，选Systrace
需要分析应用流程和耗时，选TraceView / 插桩之后的Systrace
需要分析其他应用，选Nanoscope
灰度环境分析Java代码，选Rhea

七、卡顿指标

怎么用一个指标直观反映卡顿呢?

监测指标

流畅Smoothness计算

当Vsync信号到达时会会调用HAL层的HWComposer.vsync()函数，通知HWComposer引擎进行GPU渲染和显示,，然后发送Vsync信号给SurfaceFinger处理
SurfaceFinger接收到Vsync信号后,调用SurfaceFlinger的addResyncSample函数用来处理 Vsync 信号，addResyncSample函数可以将App的渲染帧同步到显示器的刷新时间，以避免出现撕裂和卡顿等问题。
EventThread通过onVsyncEvent函数将Vsync信号分发给需要使用Vsync信号的App，实现更平滑和流畅的渲染效果
当系统收到显示器的 Vsync 信号时，DisplayEventReceiver.onVsync() 函数会被调用，并将时间戳和Displayer物理属性传递给App
App收到时间戳和Displayer物理属性后，FrameHandler可以帮助应用程序将渲染帧与 Vsync 信号同步，当 FrameHandler 接收到 Vsync 信号时，FrameHandler会调用 sendMessage() 方法，并将帧同步消息作为参数传递给该方法
流畅度存在哪些痛点问题?

流畅度存在两个痛点:

第一个痛点是: 数据量大，不方便统计，导致淹没真实卡顿Case。

第二个痛点是: 不能简单使用平均值和方差。因为不同设备的卡顿标准线不一样，我们应该按照设备等级划分标注线

流畅度指标是怎样衡量的?

指标一: 流畅度评分

压缩数据
加权放大卡顿

指标二: XPM评分(denzelzhou)：离散程度

帧绘制时长到标准绘制时长的距离（点到线的距离）
距离标准绘制时长越远就越卡顿

八、监测SOP

监测范围

慢函数监测

技术需求: 通过外部配置阈值记录Android慢函数,如果超过阈值，那么将慢函数方法名和耗时间信息记录在本地JSON文件

思路:

首先定义一个类 SlowFunctionClassVisitor，继承自 ClassVisitor，用于实现对类的字节码的修改。
在 SlowFunctionClassVisitor 中重写 visitMethod 方法，用于实现对方法的字节码的修改。在 visitMethod 方法中，先调用父类的 visitMethod 方法，然后使用 ASM 的 API 生成新的方法字节码，并将原来的方法字节码替换为新的方法字节码。
在生成新的方法字节码时，使用 Label 和 JumpInsnNode 等 ASM 的 API 插入代码，实现对方法的耗时进行判断。如果方法耗时超过阈值，则记录慢函数信息，并将其写入本地 JSON 文件中。
为了实现记录慢函数信息和将其写入本地 JSON 文件中，使用了 org.json.JSONObject 和 java.io.FileWriter 等相关的 API。

假设我们要记录的慢函数是指执行时间超过100ms的函数，并且阈值的配置方式是通过一个配置文件，其中包含一个键值对 "slow_function_threshold=100"，存放在assets目录下的config.json文件中。

首先，在Android Studio中创建一个新的Android项目，并将以下代码添加到build.gradle文件的dependencies块中：

dependencies {
    implementation 'org.ow2.asm:asm:9.2'
    implementation 'org.ow2.asm:asm-util:9.2'
}

接下来，我们需要创建一个ASM的ClassVisitor，用于在方法调用前后插入代码。

public class SlowFunctionClassVisitor extends ClassVisitor {
    private String className;
    public SlowFunctionClassVisitor(ClassVisitor classVisitor) {
        super(Opcodes.ASM9, classVisitor);
    }
    @Override
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
        className = name;
        super.visit(version, access, name, signature, superName, interfaces);
    }
    @Override
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
        MethodVisitor mv = cv.visitMethod(access, name, descriptor, signature, exceptions);
        return new SlowFunctionMethodVisitor(Opcodes.ASM9, mv, access, name, descriptor, className);
    }
    private static class SlowFunctionMethodVisitor extends AdviceAdapter {
        private final String methodName;
        private final String className;
        protected SlowFunctionMethodVisitor(int api, MethodVisitor mv, int access, String name, String descriptor, String className) {
            super(api, mv, access, name, descriptor);
            this.methodName = name;
            this.className = className;
        }
        private static final String startTimeFieldName = "_start_time";
        @Override
        protected void onMethodEnter() {
            //在方法进入时插入代码
            visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
            visitLdcInsn("enter " + methodName);
            visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
            visitVarInsn(Opcodes.ALOAD, 0);
            visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J", false);
            visitFieldInsn(Opcodes.PUTFIELD, className, startTimeFieldName, "J");
        }
        @Override
        protected void onMethodExit(int opcode) {
            //在方法退出时插入代码
            visitVarInsn(Opcodes.ALOAD, 0);
            visitFieldInsn(Opcodes.GETFIELD, className, startTimeFieldName, "J");
            visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J", false);
            visitInsn(Opcodes.LSUB);
            visitVarInsn(Opcodes.LSTORE, 2);
            Label l1 = new Label();
            visitVarInsn(Opcodes.LLOAD, 2);
        visitLdcInsn(100L);  // 100ms
        visitInsn(Opcodes.LCMP);
        visitJumpInsn(Opcodes.IFLE, l1);
        // 超过阈值，记录慢函数信息
        visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
        visitLdcInsn("exit " + methodName + " cost " + Long.toString(2L) + " ms");
        visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
        // 加载阈值
        visitLdcInsn("slow_function_threshold");
        visitMethodInsn(Opcodes.INVOKESTATIC, "android/content/res/Resources", "getSystem", "()Landroid/content/res/Resources;", false);
        visitMethodInsn(Opcodes.INVOKEVIRTUAL, "android/content/res/Resources", "getAssets", "()Landroid/content/res/AssetManager;", false);
        visitLdcInsn("config.json");
        visitMethodInsn(Opcodes.INVOKEVIRTUAL, "android/content/res/AssetManager", "open", "(Ljava/lang/String;)Ljava/io/InputStream;", false);
        visitTypeInsn(Opcodes.NEW, "org/json/JSONObject");
        visitInsn(Opcodes.DUP);
        visitTypeInsn(Opcodes.NEW, "java/io/InputStreamReader");
        visitInsn(Opcodes.DUP);
        visitVarInsn(Opcodes.ALOAD, 4);
        visitMethodInsn(Opcodes.INVOKESPECIAL, "java/io/InputStreamReader", "<init>", "(Ljava/io/InputStream;)V", false);
        visitMethodInsn(Opcodes.INVOKESPECIAL, "org/json/JSONObject", "<init>", "(Ljava/io/Reader;)V", false);
        visitLdcInsn("slow_function_threshold");
        visitMethodInsn(Opcodes.INVOKEVIRTUAL, "org/json/JSONObject", "optInt", "(Ljava/lang/String;)I", false);
        // 比较耗时和阈值
        visitVarInsn(Opcodes.LLOAD, 2);
        visitInsn(Opcodes.LCMP);
        visitVarInsn(Opcodes.ILOAD, 5);
        Label l2 = new Label();
        visitJumpInsn(Opcodes.IF_ICMPLE, l2);
        // 超过阈值，写入本地JSON文件
        visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
        visitLdcInsn("write to local json file: " + methodName + " cost " + Long.toString(2L) + " ms");
        visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
        visitTypeInsn(Opcodes.NEW, "org/json/JSONObject");
        visitInsn(Opcodes.DUP);
        visitVarInsn(Opcodes.ALOAD, 0);
        visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Class", "getName", "()Ljava/lang/String;", false);
        visitLdcInsn(methodName);
        visitVarInsn(Opcodes.LLOAD, 2);
        visitMethodInsn(Opcodes.INVOKESPECIAL, "org/json/JSONObject", "<init>", "()V", false);
        visitVarInsn(Opcodes.ASTORE, 6);
        visitTypeInsn(Opcodes.NEW, "java/io/FileWriter");
        visitInsn(Opcodes.DUP);
        visitLdcInsn("slow_function.json");
        visitMethodInsn(Opcodes.INVOKESPECIAL, "java/io/FileWriter", "<init>", "(Ljava/lang/String;)V", false);
        visitVarInsn(Opcodes.ASTORE, 7);
        // 将慢函数信息写入JSON文件
        visitVarInsn(Opcodes.ALOAD, 7);
        visitVarInsn(Opcodes.ALOAD, 6);
        visitMethodInsn(Opcodes.INVOKEVIRTUAL, "org/json/JSONObject", "toString", "()Ljava/lang/String;", false);
        visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/FileWriter", "write", "(Ljava/lang/String;)V", false);
        visitVarInsn(Opcodes.ALOAD, 7);
        visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/FileWriter", "flush", "()V", false);
        visitVarInsn(Opcodes.ALOAD, 7);
        visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/FileWriter", "close", "()V", false);
        visitLabel(l2);
    }
    super.visitInsn(opcode);
}
}

以上是一段使用ASM技术实现记录Android慢函数的代码。它通过在方法的字节码中插入代码来判断方法耗时，如果超过阈值，就记录慢函数信息，并将其写入本地JSON文件中。在实现过程中，使用了ASM的相关API来生成字节码，并在方法执行过程中进行修改。

流畅性监测

Activity、Service、Receiver 组件生命周期的耗时和调用次数也是我们重点关注的性能问题。

例如Activity的onCreate不应该超过 1 秒，不然会影响用户看到页面的时间。

Service 和 Receiver 虽然是后台组件，不过它们的生命周期也是占用主线程的，也是我们需要关注的问题。对于组件生命周期我们应该采用更严格的监测，可以全量上报各个组件各个生命周期的启动时间和启动次数。一般的做法是，通过编译时插桩来做到组件的生命周期监测。

FPS监测

我们需要采集的卡顿数据有: 卡顿次数/交互次数比，帧绘制时间采样. 处理方式可以参考下面的内容:

定义一个FPS监测类，该类中包含FPS计算的逻辑：

public class FPSMonitor {
    private static final long ONE_SECOND = 1000000000L;
    private long lastTime = System.nanoTime();
    private int frameCount = 0;
    private int fps = 0;
    public void update() {
        long currentTime = System.nanoTime();
        frameCount++;
        if (currentTime - lastTime >= ONE_SECOND) {
            fps = frameCount;
            frameCount = 0;
            lastTime = currentTime;
        }
    }
    public int getFps() {
        return fps;
    }
}

使用ASM字节码框架在编译期间对代码进行插桩，将FPS监测的逻辑插入到游戏或应用程序的主循环中：

public class GameLoop {
    private FPSMonitor fpsMonitor = new FPSMonitor();
    public void loop() {
        while (true) {
            long startTime = System.nanoTime();
            // 游戏或应用程序的主逻辑// ...// 在主循环中插入FPS监测逻辑
            fpsMonitor.update();
            int fps = fpsMonitor.getFps();
            System.out.println("FPS: " + fps);
            // 控制FPS为60long elapsedTime = System.nanoTime() - startTime;
            long sleepTime = (1000000000L / 60) - elapsedTime;
            if (sleepTime > 0) {
                try {
                    Thread.sleep(sleepTime / 1000000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FPS监测逻辑被插入到了应用程序的主循环中，在每一帧结束时计算FPS，并将计算结果输出到控制台。我们使用插件可以将上述代码转换成字节码文件。转换代码如下:

public class FpsMonitorClassVisitor extends ClassVisitor {
    public FpsMonitorClassVisitor(ClassVisitor classVisitor) {
        super(Opcodes.ASM5, classVisitor);
    }
    @Override
    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
        MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
        if (name.equals("loop")) {
            mv = new FpsMonitorMethodVisitor(mv);
        }
        return mv;
    }
    private static class FpsMonitorMethodVisitor extends MethodVisitor {
        public FpsMonitorMethodVisitor(MethodVisitor mv) {
            super(Opcodes.ASM5, mv);
        }
        @Override
        public void visitCode() {
            super.visitCode();
            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitFieldInsn(Opcodes.GETFIELD, "GameLoop", "fpsMonitor", "LFPSMonitor;");
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "FPSMonitor", "update", "()V", false);
            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitFieldInsn(Opcodes.GETFIELD, "GameLoop", "fpsMonitor", "LFPSMonitor;");
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "FPSMonitor", "getFps", "()I", false);
            mv.visitFieldInsn(Opcodes.PUTSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
            mv.visitInsn(Opcodes.SWAP);
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(I)V", false);
        }
    }
}

创建了一个 FpsMonitorClassVisitor 类来处理插桩逻辑，它继承自 ClassVisitor 类。

在 visitMethod 方法中，我们判断当前访问的方法是否为 loop 方法，如果是，则创建一个 FpsMonitorMethodVisitor 对象来处理该方法的插桩逻辑。

在 FpsMonitorMethodVisitor 中，我们将 FPS 监测逻辑插入到了游戏或应用程序的主循环中，在每一帧结束时计算 FPS，并将计算结果输出到控制台。

最后，我们将创建的 FpsMonitorClassVisitor 对象传递给 ASM 的 ClassReader，并通过 ClassWriter 来生成修改后的字节码。

Thread监测

由于文件IO开销、线程间的竞争或者锁可能会导致主线程空等，从而导致卡顿。我们可以借助BHook对线程进行监测，需要监测以下两点：

线程数量

需要监测线程数量的多少，以及创建线程的方式。例如有没有使用统一的线程池，这块可以通过 hook 线程的 nativeCreate() 函数，主要用于进行线程收敛，减少线程数量。

线程时间

监测线程的用户时间 utime、系统时间 stime 和优先级。主要是看哪些线程 utime+stime 时间比较多，占用了过多的 CPU。

上报时机

超过设置慢函数的阈值，开始收集慢方法函数和时间，开始上报。

业务降级

可通过参数配置平台配置开关，随时回归线上版本

注意事项

插桩方案问题	解决方案
包大小增加多少	过滤简单函数：i++，getter/setter支持黑名单配置包大小控制2%
只能监测到应用堆栈耗时，无法收集系统堆栈耗时	结合Looper方案，同时上报后台根据卡顿key来聚合分析
APP性能影响范围	非业务模块不要插桩，避免对稳定性造成影响

方案优化

为了提高自身性能，我们是不是可以同步线程方式进一步优化获取堆栈性能

getStackTrace

getStackTrace获取堆栈信息有如下两大业务痛点:

性能损耗
需要暂停主线程运行

为了解决上述业务痛点，我们可以采取ThreadDump和AsyncGetCallTrace两种解决方案。

方案	实现	特点
StackSampler	依赖SafePoint收集	公开API，稳定，有停顿
AsyncGetCallTrace	SIGPROF定时器，Native层收集堆栈	非公开API，兼容性问题无停顿

StackSampler

在SafePoint处，JVM可以确保所有线程都停止执行，从而保证当前状态的一致性。利用SafePoint，我们可以实现无需挂起主线程的异步堆栈采样，从而避免了主线程被挂起的影响。

public class StackSampler {
    private static final int MAX_STACK_DEPTH = 32; // 最大堆栈深度
    private static final int MAX_STACK_SAMPLES = 100; // 最大缓存采样数
    private static final long SAMPLE_INTERVAL = 100L; // 采样间隔，单位：毫秒
    private final ConcurrentLinkedQueue<String> stackSamples; // 堆栈采样缓存
    private final AtomicBoolean profiling; // 采样标志位
    public StackSampler() {
        stackSamples = new ConcurrentLinkedQueue<>();
        profiling = new AtomicBoolean(false);
    }
    // SafePoint 采样方法
    private void sample() {
        if (profiling.compareAndSet(false，true)) {
            // 在 SafePoint 处异步采样堆栈信息
            new Thread(() -> {
                // 延迟一段时间，等待所有线程进入 SafePoint
                try {
                    Thread.sleep(SAMPLE_INTERVAL);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 采样堆栈信息并添加到缓存中
                String stackTrace = getStackTrace();
                stackSamples.offer(stackTrace);
                // 重置采样标志位
                profiling.set(false);
            }).start();
        }
    }
    // 获取当前线程的堆栈信息
    private String getStackTrace() {
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        StringBuilder sb = new StringBuilder();
        for (int i = 2; i < Math.min(stackTrace.length,，AX_STACK_DEPTH + 2); i++) {
            sb.append(stackTrace[i].toString()).append('\n');
        }
        return sb.toString();
    }
    // 输出所有采样结果
    public void dump() {
        int count = 0;
        String stackTrace;
        while ((stackTrace = stackSamples.poll()) != null && count < MAX_STACK_SAMPLES) {
            System.out.println(stackTrace);
            count++;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        StackSampler sampler = new StackSampler();
        sampler.sample(); // 开始采样
        Thread.sleep(MAX_STACK_SAMPLES * SAMPLE_INTERVAL); // 等待采样完成
        sampler.dump(); // 输出采样结果
    }
}

用SafePoint实现了异步堆栈采样，并在每次采样时延迟一段时间，等待所有线程进入SafePoint，以确保采样的堆栈信息是当前线程的真实状态。同时，采样的结果存储在一个线程安全的队列中，等待输出。当采样完成后，通过 dump() 方法输出所有的采样。

另外，为了避免频繁地采样堆栈信息导致性能问题，我们可以通过减少采样频率的方式进行优化。例如，可以通过将采样间隔从10毫秒调整为100毫秒，来减少采样的次数，从而降低对系统性能的影响。

另外，为了更高效地采样和处理堆栈信息，我们可以考虑采用缓存和批量处理的策略。例如，可以将采样的结果存储在一个缓存队列中，当队列达到一定大小时再进行批量处理，从而减少对队列的频繁访问和操作，提高程序的执行效率。

AsyncGetCallTrace

通过使用SIGPROF定时器，Native层收集堆栈方式，优化getStackTrace获取堆栈需要暂停主线程运行和相关性能问题

#include <signal.h>
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <execinfo.h>
#define SAMPLE_INTERVAL 100 // 采样间隔，单位：毫秒
#define MAX_STACK_DEPTH 32 // 最大堆栈深度
#define MAX_STACK_SAMPLES 100 // 最大缓存采样数
volatile sig_atomic_t profiling = 0; // 采样标志位
// SIGPROF 信号处理函数
void profiling_handler(int signum) {
    profiling = 1; // 标记需要采样堆栈信息
}
// 开始采样
void start_profiling() {
    struct sigaction sa;
    struct itimerval timer;
    // 注册 SIGPROF 信号处理函数
    sa.sa_handler = profiling_handler;
    sa.sa_flags = SA_RESTART;
    sigemptyset(&sa.sa_mask);
    sigaction(SIGPROF, &sa, NULL);
    // 设置定时器
    timer.it_value.tv_sec = SAMPLE_INTERVAL / 1000;
    timer.it_value.tv_usec = (SAMPLE_INTERVAL % 1000) * 1000;
    timer.it_interval = timer.it_value;
    setitimer(ITIMER_PROF, &timer, NULL);
}
// 停止采样
void stop_profiling() {
    struct itimerval timer;
    // 关闭定时器
    timer.it_value.tv_sec = 0;
    timer.it_value.tv_usec = 0;
    timer.it_interval = timer.it_value;
    setitimer(ITIMER_PROF, &timer, NULL);
}
// 收集堆栈信息并输出到标准输出流
void dump_stack() {
    void *stack[MAX_STACK_DEPTH];
    int depth = backtrace(stack, MAX_STACK_DEPTH);
    if (depth > 0) {
        backtrace_symbols_fd(stack, depth, STDOUT_FILENO);
    }
}
int main() {
    start_profiling(); // 开始采样
    int sample_count = 0;
    while (sample_count < MAX_STACK_SAMPLES) {
        if (profiling) { // 如果需要采样堆栈信息
            profiling = 0; // 重置采样标志位
            dump_stack(); // 收集堆栈信息
            sample_count++; // 统计采样数
        }
    }
    stop_profiling(); // 停止采样
    return 0;
}

start_profiling() 和 stop_profiling() 函数用于开启和关闭 SIGPROF 定时器，定时器的时间间隔由 SAMPLE_INTERVAL 宏定义指定。

profiling_handler() 函数是 SIGPROF 信号的处理函数，每次接收到信号后，将 profiling 变量置为 1。dump_stack() 函数用于收集堆栈信息，通过 backtrace() 函数获取堆栈信息，并输出到标准输出流中。

在 main() 函数中，循环收集堆栈信息，直到采样数达到最大值为止，最大采样数由 MAX_STACK_SAMPLES 宏定义指定。

通过 SIGPROF 定时器和信号处理函数的方式，可以在 Native 层收集堆栈信息，避免了在 Java 层获取堆栈信息的开销和性能问题。不过需要注意的是，堆栈采样对应用程序的性能有一定影响，需要权衡好采样间隔和采样深度等参数

九、总结展望

当测试提出卡顿问题，测试会新建Bug单给责任人处理。导致卡顿的原因有很多，比如函数非常耗时、I/O 非常慢、线程或锁间竞争等。

随着移动端用户越来越注重产品体验，APM系统也逐渐成为互联网公司重要基础设施。

卡顿是衡量App性能的一个重要指标，建设卡顿APM监测平台是Android卡顿优化长效治理关键。

同时，通过建设卡顿APM监测平台，帮助业务找到卡顿原因也是架构组TL考核评测员工重点OKR指向。

为了解决卡顿标准不明确问题，小木箱今天和大家着重探讨了卡顿监测的方方面面。

如果小木箱的文章对你有所帮助，那么欢迎关注小木箱的公众号: 小木箱成长营。我是小木箱，我们下一篇见~

参考链接

卡顿监测 · 方案篇 · Android卡顿监测指导原则（2）

六、分析工具

工具对比

使用指南

七、卡顿指标

监测指标

流畅Smoothness计算

八、监测SOP

监测范围

慢函数监测

流畅性监测

FPS监测

Thread监测

线程数量

线程时间

上报时机

业务降级

注意事项

方案优化

getStackTrace

StackSampler

AsyncGetCallTrace

九、总结展望

热门文章

最新文章

相关课程

相关电子书

相关实验场景

卡顿监测 · 方案篇 · Android卡顿监测指导原则（2）

六、 分析工具

工具对比

使用指南

七、 卡顿指标

监测指标

流畅Smoothness计算

八、监测SOP

监测范围

慢函数监测

流畅性监测

FPS监测

Thread监测

线程数量

线程时间

上报时机

业务降级

注意事项

方案优化

getStackTrace

StackSampler

AsyncGetCallTrace

九、总结展望

热门文章

最新文章

相关课程

相关电子书

相关实验场景

六、分析工具

七、卡顿指标