版本

v0.6.5

温馨提示

TracePlugin 是比较复杂的，很多东西文章中可能讲的不是很清楚，配合 推荐 Matrix 源码完整注释
可能会有更好的效果

概述

本篇文章是 腾讯开源的 APM 框架 Matrix 系列文章的第三篇，将对 matrix-trace-canary这个模块架构进行解析。这个模块中包含了帧率（FPS）检测，启动时间检测（APP启动和Activity启动），ANR检测，慢函数检测，这四个Tracer，后面我们会一一进行分析。上一篇为腾讯 Apm 框架 Matrix 源码阅读 - 架构解析

先看一下类图及类功能的简介。

TraceCanary架构图 .jpg

• LooperMonitor：通过给主线程Looper设置Printer来监控 Looper分发事件的开始和结束。
• UIThreadMonitor：反射 Choreographer并获得每一个状态的 CallbackQueue对象 和 mFrameIntervalNanos属性值,配合 LooperMonitor使 LooperObserver具有感知每帧 开始，执行，结束具体时间的能力。
• LooperObserver：具有感知每个Message开始，执行，结束具体时间的能力。
• AppMethodBeat:还记得在 腾讯 Apm 框架 Matrix 源码阅读 - gradle插件中说了，在编译器Matrix会对复杂方法进行字节码插桩，那插桩的是什么内容呢？就是在复杂方法的入口插入 AppMethodBeat.i(),方法的出口插入AppMethodBeat.O()方法。在Activity的中插入 AppMethodBeat.at()方法。这个类主要作用就是收集各个方法的methodId和执行时间并存放在自己的 sBuffer变量中，同时AppMethodBeat也能感知到某个activity是否获取到焦点，具体功能主要是在at方法中。
• IAppForeground:在 腾讯 Apm 框架 Matrix 源码阅读 - 架构解析 中提到过。可以感知 APP 进入前台还是 退出到后台
• ITracer: 继承了 IAppForeground 是所有Tracer的父接口，具有 isAlive(),onStartTrace(),onCloseTrace()这三个抽象方法。
• Tracer:是所有Tracer的直接父类，实现了ITracer接口继承了LooperObserver类，通过上面说的Tracer天然具有 感知APP 进入前台还是 退出到后台的能力和感知每个Message 开始，执行，结束具体时间的能力。

下面我们就从TracePlugin这个入口类开始看。

1. TracePlugin

先看一下TracePlugin的构造方法,没什么可以说的，就是将配置传进来并进行保存，配置中记录了那些Tracer可用那些不可用，还记录了我们设置的SplashActivity

    public TracePlugin(TraceConfig config) {
        this.traceConfig = config;
    }

  public class TraceConfig implements IDefaultConfig {
   ....
    public IDynamicConfig dynamicConfig;
    public boolean defaultFpsEnable;
    public boolean defaultMethodTraceEnable;
    public boolean defaultStartupEnable;
    public boolean defaultAnrEnable;
    public boolean isDebug;
    public boolean isDevEnv;
    public String splashActivities;//可配置多个用 ; 隔开，但是生效的还是只有第一个
    public Set<String> splashActivitiesSet;
   ....
}

1.1 TracePlugin.init()

在腾讯 Apm 框架 Matrix 源码阅读 - 架构解析中讲过每个Plugin都具有一些生命周期方法，那么下来就依次看看TracePlugin在这些生命周期中做了那些事情。首先是 init（）方法,可以看到init（）方法中首先判断当前SDK的版本是否小于16如果小于16就直接返回了，如果大于等于16就创建各个Tracer。这里顺便说一下 之所以把插件的最低支持版本设置为16 是因为Choreographer.getInstance()方法是Api16才提供的

    @Override
    public void init(Application app, PluginListener listener) {
        //APi小于16 不支持
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
            MatrixLog.e(TAG, "[FrameBeat] API is low Build.VERSION_CODES.JELLY_BEAN(16), TracePlugin is not supported");
            unSupportPlugin();
            return;
        }

        anrTracer = new AnrTracer(traceConfig);

        frameTracer = new FrameTracer(traceConfig);

        evilMethodTracer = new EvilMethodTracer(traceConfig);

        startupTracer = new StartupTracer(traceConfig);
    }

1.2 TracePlugin.start()

 @Override
    public void start() {
        super.start();
       ....
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                //初始化 UIThreadMonitor
                if (!UIThreadMonitor.getMonitor().isInit()) {
                    try {
                        //详见【2.1】
                        UIThreadMonitor.getMonitor().init(traceConfig);
                    } catch (java.lang.RuntimeException e) {
                        return;
                    }
                }
                //启动 AppMethodBeat 详见【3.1】
                AppMethodBeat.getInstance().onStart();
                //启动 UIThreadMonitor 详见【2.9】
                UIThreadMonitor.getMonitor().onStart();
                anrTracer.onStartTrace();
                frameTracer.onStartTrace();
                evilMethodTracer.onStartTrace();
                startupTracer.onStartTrace();
            }
        };

        if (Thread.currentThread() == Looper.getMainLooper().getThread()) {
            runnable.run();
        } else {
            //post到主线程启动
            MatrixHandlerThread.getDefaultMainHandler().post(runnable);
        }

    }

在start()方法中主要是在主线程中启动 UIThreadMonitor,AppMethodBeat还有各个Tracer

1.3 TracePlugin.stop()

    @Override
    public void stop() {
        .....
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                //详见【3.2】
                AppMethodBeat.getInstance().onStop();
                UIThreadMonitor.getMonitor().onStop();
                anrTracer.onCloseTrace();
                frameTracer.onCloseTrace();
                evilMethodTracer.onCloseTrace();
                startupTracer.onCloseTrace();
            }
        };

        if (Thread.currentThread() == Looper.getMainLooper().getThread()) {
            runnable.run();
        } else {
            MatrixHandlerThread.getDefaultMainHandler().post(runnable);
        }
    }

stop()方法中主要是在主线程中停止UIThreadMonitor,AppMethodBeat还有各个Tracer

1.4 TracePlugin.onForeground()

    @Override
    public void onForeground(boolean isForeground) {
       ....
        if (frameTracer != null) {
            frameTracer.onForeground(isForeground);
        }
        if (anrTracer != null) {
            anrTracer.onForeground(isForeground);
        }
        if (evilMethodTracer != null) {
            evilMethodTracer.onForeground(isForeground);
        }
        if (startupTracer != null) {
            startupTracer.onForeground(isForeground);
        }
    }

onForeground方法就是将APP处于前台或者后台的状态分发给各个Tracer。可见TracePlugin中的工作还是蛮简单的就是初始化，启动，分发，暂停。

2.1 UIThreadMonitor.init(traceConfig)

  public void init(TraceConfig config) {
        //不是主线程 就抛出异常
        if (Thread.currentThread() != Looper.getMainLooper().getThread()) {
            throw new AssertionError("must be init in main thread!");
        }
        this.config = config;
        //从当前线程中获取到 Choreographer 对象
        choreographer = Choreographer.getInstance();
        // 获得 Choreographer 里的 mLock锁 对象
        callbackQueueLock = reflectObject(choreographer, "mLock");
        // 获得 Choreographer 里的 mCallbackQueues 对象
        callbackQueues = reflectObject(choreographer, "mCallbackQueues");

        //反射获得 callbackQueues 中第一个 CallbackQueue对象的 addCallbackLocked 的方法
        // 第一个 CallbackQueue 是处理 input事件的
        addInputQueue = reflectChoreographerMethod(callbackQueues[CALLBACK_INPUT], ADD_CALLBACK, long.class, Object.class, Object.class);
        //反射获得 callbackQueues 中第二个 CallbackQueue对象的 addCallbackLocked 的方法
        // 第二个 CallbackQueue 是处理 动画的
        addAnimationQueue = reflectChoreographerMethod(callbackQueues[CALLBACK_ANIMATION], ADD_CALLBACK, long.class, Object.class, Object.class);
        //反射获得 callbackQueues 中第三个 CallbackQueue对象的 addCallbackLocked 的方法
        // 第三个 CallbackQueue 是绘制完 用于回调的
        addTraversalQueue = reflectChoreographerMethod(callbackQueues[CALLBACK_TRAVERSAL], ADD_CALLBACK, long.class, Object.class, Object.class);

        // 获取 choreographer 中mFrameIntervalNanos 的值 并赋值给 frameIntervalNanos
        frameIntervalNanos = reflectObject(choreographer, "mFrameIntervalNanos");

        //注册一个 LooperDispatchListener 详见【2.2】
        LooperMonitor.register(new LooperMonitor.LooperDispatchListener() {
            @Override
            public boolean isValid() {
                return isAlive;
            }

            @Override
            public void dispatchStart() {
                super.dispatchStart();
                //详见【2.7】
                UIThreadMonitor.this.dispatchBegin();
            }

            @Override
            public void dispatchEnd() {
                super.dispatchEnd();
                //详见【2.8】
                UIThreadMonitor.this.dispatchEnd();
            }

        });
        this.isInit = true;
        .....
    }

UIThreadMonitor.init主要做了三件事

1. 反射获得 CALLBACK_INPUT,CALLBACK_ANIMATION,CALLBACK_TRAVERSAL这三个状态的addCallbackLocked并记录到自己的成员变量中
2. 反射获得Choreographer记录的mFrameIntervalNanos变量并记录到自己的成员变量中。mFrameIntervalNanos的值在现在大部分手机设备上都是16666666
3. 向LooperMonitor中注册一个LooperDispatchListener监听用来监控 Looper分发事件的开始和结束。

2.2 LooperMonitor.register()

     //饿汉式单例 详见【2.3】
    private static final LooperMonitor mainMonitor = new LooperMonitor();

    static void register(LooperDispatchListener listener) {
        mainMonitor.addListener(listener);
    }

LooperMonitor.register没啥可讲，不过 LooperMonitor对象的创建使用了饿汉式单例的方式，我们一起看看它的构造方法中干了什么

2.3 LooperMonitor <init>

    public LooperMonitor(Looper looper) {
        Objects.requireNonNull(looper);
        this.looper = looper;
        //添加 自定义的 Printer 详见【2.4】
        resetPrinter();
        //添加 IdleHandler
        addIdleHandler(looper);
    }

    private LooperMonitor() {
        this(Looper.getMainLooper());
    }

可见无参构造获取到主线程Looper后调用到了有参构造

2.4 LooperMonitor.resetPrinter()

  private synchronized void resetPrinter() {
        Printer originPrinter = null;
        try {
            if (!isReflectLoggingError) {
                //获取之前的 Printer ,防止项目其他功能在 设置了 这个 Printer， 如果直接设置
                //那其他 工具就不能正常运行了 大厂的程序员 还是细啊！！
                originPrinter = ReflectUtils.get(looper.getClass(), "mLogging", looper);
                //如果已经 hook过 就直接返回
                if (originPrinter == printer && null != printer) {
                    return;
                }
            }
        } 
        ....
        //设置自己的Printer 详见【2.5】
        looper.setMessageLogging(printer = new LooperPrinter(originPrinter));
        ....
    }

该方法主要通过反射获取主线程Looper的Printer进行保存,然后通过Api设置自定义的LooperPrinter。这里保存Looper之前的Printer主要是防止和其他框架冲突导致其他框架不能正常工作，再感叹一次，大厂程序员还是细啊....

2.5 LooperPrinter.println()

  @Override
        public void println(String x) {
            if (null != origin) {
                //执行原始printer的 println方法
                origin.println(x);
               ...
            }
           ....
            if (isValid) {
                //详见【2.6】
                dispatch(x.charAt(0) == '>', x);
            }

        }

2.6 LooperPrinter.dispatch()

 private void dispatch(boolean isBegin, String log) {

        for (LooperDispatchListener listener : listeners) {
            if (listener.isValid()) {
                if (isBegin) {
                    if (!listener.isHasDispatchStart) {
                        //分发开始
                        listener.onDispatchStart(log);
                    }
                } else {
                    if (listener.isHasDispatchStart) {
                        //分发结束
                        listener.onDispatchEnd(log);
                    }
                }
            } else if (!isBegin && listener.isHasDispatchStart) {
                //分发结束
                listener.dispatchEnd();
            }
        }

    }

通过该方法就会通知给所有的LooperDispatchListener当前是Looper刚开始分发还是已经分发完成。【2.1】中说过UIThreadMonitor.init想注册了一个LooperDispatchListener所以我们继续回到 UIThreadMonitor类中

2.7 UIThreadMonitor.this.dispatchBegin

    private void dispatchBegin() {
        //记录 dispatch 的起始时间
        token = dispatchTimeMs[0] = SystemClock.uptimeMillis();
        // 记录 当前线程时间
        dispatchTimeMs[2] = SystemClock.currentThreadTimeMillis();
        // 调用 i 方法
        AppMethodBeat.i(AppMethodBeat.METHOD_ID_DISPATCH);

        synchronized (observers) {
            //回调 所有 LooperObserver 的 dispatchBegin 方法
            for (LooperObserver observer : observers) {
                if (!observer.isDispatchBegin()) {
                    observer.dispatchBegin(dispatchTimeMs[0], dispatchTimeMs[2], token);
                }
            }
        }
    }

该方法中记录了dispatch开始的时间并将 Looper开始分发事件 这个消息通知给了各个 LooperObserver，我们在最开始介绍过Tracer类就继承了LooperObserver这也就是所有Tracer都具有感知每个Message开始，执行，结束具体时间的能力。

2.8 UIThreadMonitor.this.dispatchEnd

private void dispatchEnd() {

        //帧刷新结束
        if (isBelongFrame) {
             //详见【2.14】
            doFrameEnd(token);
        }

        //dispatch 起始时间
        long start = token;
        //dispatch 结束时间
        long end = SystemClock.uptimeMillis();

        synchronized (observers) {
            //回调 所有 LooperObserver 的 doFrame 方法
            for (LooperObserver observer : observers) {
                if (observer.isDispatchBegin()) {
                    //参数含义 在 LooperObserver接口中查询
                    observer.doFrame(AppMethodBeat.getVisibleScene(), token, SystemClock.uptimeMillis(), isBelongFrame ? end - start : 0, queueCost[CALLBACK_INPUT], queueCost[CALLBACK_ANIMATION], queueCost[CALLBACK_TRAVERSAL]);
                }
            }
        }

        //记录 当前线程时间
        dispatchTimeMs[3] = SystemClock.currentThreadTimeMillis();
        // 记录 dispatch 的结束时间
        dispatchTimeMs[1] = SystemClock.uptimeMillis();
        // 调用 o 方法
        AppMethodBeat.o(AppMethodBeat.METHOD_ID_DISPATCH);

        synchronized (observers) {
            // 回调 所有 LooperObserver的 dispatchEnd 方法
            for (LooperObserver observer : observers) {
                if (observer.isDispatchBegin()) {
                    observer.dispatchEnd(dispatchTimeMs[0], dispatchTimeMs[2], dispatchTimeMs[1], dispatchTimeMs[3], token, isBelongFrame);
                }
            }
        }

    }

这个方法中 记了了各个时间点并回调了LooperObserver的doFrame和dispatchEnd方法。LooperObserver 中各个方法的各个参数的含义见附录1

2.9 UIThreadMonitor.onStart()

    //标识对应 type 执行 开始 或者 结束
    private int[] queueStatus = new int[CALLBACK_LAST + 1];
    //type对应的 执行时间
    private long[] queueCost = new long[CALLBACK_LAST + 1];

    public synchronized void onStart() {
        if (!isInit) {
            throw new RuntimeException("never init!");
        }
        if (!isAlive) {
            this.isAlive = true;
            synchronized (this) {
                MatrixLog.i(TAG, "[onStart] callbackExist:%s %s", Arrays.toString(callbackExist), Utils.getStack());
                callbackExist = new boolean[CALLBACK_LAST + 1];
            }
            queueStatus = new int[CALLBACK_LAST + 1];
            queueCost = new long[CALLBACK_LAST + 1];
            //详见【2.10】
            addFrameCallback(CALLBACK_INPUT, this, true);
        }
    }

这个方法主要是 重置queueStatus和queueCost这两个重要的成员变量，然后调用addFrameCallback方法

2.10 UIThreadMonitor.addFrameCallback()

 private synchronized void addFrameCallback(int type, Runnable callback, boolean isAddHeader) {
        ....
        try {
            synchronized (callbackQueueLock) {//和 Choreographer 中使用相同的 锁对象 都是 mLock
                Method method = null;
                switch (type) {
                    case CALLBACK_INPUT:
                        method = addInputQueue;
                        break;
                    case CALLBACK_ANIMATION:
                        method = addAnimationQueue;
                        break;
                    case CALLBACK_TRAVERSAL:
                        method = addTraversalQueue;
                        break;
                }
                if (null != method) {
                    //反射执行 CallbackQueue 的 addCallbackLocked 方法 ，并将我们自己的 callback 添加到回到队列中,在一帧绘制完毕后
                    // 会回调callback的run（）方法
                    method.invoke(callbackQueues[type], !isAddHeader ? SystemClock.uptimeMillis() : -1, callback, null);
                    callbackExist[type] = true;
                }
            }
        } catch (Exception e) {
            MatrixLog.e(TAG, e.toString());
        }
    }

如果你对Choreographer这个类不太了解那你需要先看看Choreographer原理 。我们这里只对里面的vsync分类简单介绍：
Choreographer的vsync回调事件分四类

• INPUT：输入事件（输入回调，为了尽快响应用户操作）
• ANIMATION：动画
• TRAVERSAL：窗口刷新，执行measure/layout/draw操作（处理布局和绘图的回调）
• COMMIT：遍历完成的提交操作，用来修正动画启动时间（绘制完成后的一些操作）

好了，我们继续来看UIThreadMonitor.addFrameCallback，这个方法的功能就是将我们自定义的回调方法加入到Choreographer的回调队列中（回调队列有多种），当一帧刷新完成后会调用我们回调的run方法，因为【2.9】中的回调对象是this所以我们接下来进入到UIThreadMonitor.run

2.11 UIThreadMonitor.run

  @Override
    public void run() {
        final long start = System.nanoTime();
        try {
            //详见 【2.12】
            doFrameBegin(token);
            //详见 【2.13】
            doQueueBegin(CALLBACK_INPUT);//input开始
            addFrameCallback(CALLBACK_ANIMATION, new Runnable() {
                @Override
                public void run() {
                    //详见 【2.14】
                    doQueueEnd(CALLBACK_INPUT);//input 结束
                    doQueueBegin(CALLBACK_ANIMATION);//animation 开始
                }
            }, true);
            addFrameCallback(CALLBACK_TRAVERSAL, new Runnable() {
                @Override
                public void run() {
                    doQueueEnd(CALLBACK_ANIMATION);//animation 结束
                    doQueueBegin(CALLBACK_TRAVERSAL);//traversal 开始
                }
            }, true);

        } finally {
            ....
            }
        }
    }

这个方法的功能就是添加CALLBACK_ANIMATION和CALLBACK_TRAVERSAL类型的回到到Choreographer的回调队列中因为CALLBACK_INPUT类型的回调已经在UIThreadMonitor.onStart中已经添加了所以这里不需要添加。

之所以为每种Type都添加监听应该是 Matrix 设计的时候计划将每一帧的耗时细化到每种Type。否则不用这么麻烦直接调用提供的apichoreographer.postFrameCallback就可以拿到每帧耗时

2.12 UIThreadMonitor.doFrameBegin

    private void doFrameBegin(long token) {
        //记录帧刷新开始
        this.isBelongFrame = true;
    }

2.13 UIThreadMonitor.doQueueBegin

    private void doQueueBegin(int type) {
        //标识当前 type 开始执行
        queueStatus[type] = DO_QUEUE_BEGIN;
        // 当前type 回调开始时间
        queueCost[type] = System.nanoTime();
    }

2.13 UIThreadMonitor.doQueueEnd

    private void doQueueEnd(int type) {
        //标识当前 type 执行结束
        queueStatus[type] = DO_QUEUE_END;
        // 当前type 执行耗时
        queueCost[type] = System.nanoTime() - queueCost[type];
        synchronized (this) {
            // 当前type的 callback 是否还存在
            callbackExist[type] = false;
        }
    }

2.14 UIThreadMonitor.doFrameEnd

  // 记录 帧结束
    private void doFrameEnd(long token) {

        doQueueEnd(CALLBACK_TRAVERSAL);//traversal 结束

        // 如果有 没有结束的回调 则报错
        for (int i : queueStatus) {
            if (i != DO_QUEUE_END) {
                queueCost[i] = DO_QUEUE_END_ERROR;
                if (config.isDevEnv) {
                    throw new RuntimeException(String.format("UIThreadMonitor happens type[%s] != DO_QUEUE_END", i));
                }
            }
        }

        //重置 queueStatus
        queueStatus = new int[CALLBACK_LAST + 1];

        //继续添加  input callback
        addFrameCallback(CALLBACK_INPUT, this, true);

        this.isBelongFrame = false;
    }

在【2.8】UIThreadMonitor.this.dispatchEnd方法中 ,也就是当一个Message分发完毕的时候调用了doFrameEnd

该方法主要是重置 queueStatus，并给Choreographer的回调队列中重新添加CALLBACK_INPUT类型的回到方法。作为下一次记录帧刷新时间的开始。

看到这里可能有人有疑惑，不是之前添加过了么，为啥这里还要再添加一次。是因为 这种监听是一次性的，Choreographer.doCallbacks()方法最后会将所有的监听都会移除.

2.15 总结一下 UIThreadMonitor的工作原理

1. 主线程Looper loop 到一个 target是 Choreographer$FrameHandler massage 是 Choreographer$FrameDisplayEventReceiver 的消息（要能触发 刷新帧）
2. 调用 dispatchBegin() 方法
3. 调用 run方法
4. 回掉 doQueueBegin type=0（input）
5. 回掉 doQueueEnd type=0（input）
6. 回掉 doQueueBegin type=1（animation）
7. 回掉 doQueueEnd type=1（animation）
8. 回掉 doQueueBegin type=2（traversal）
9. Looper中message处理完毕
10. 调用 dispatchEnd() 方法
11. 回掉 doQueueEnd type=2（traversal）

这就是 UIThreadMonitor获取一帧中每种Type耗时的流程。这个过程中UIThreadMonitor会将自己的获取到的时间通过LooperObserver这个接口分发出去。

注意：当主线程的 Looper loop 到的Message不能触发帧刷新，那么就只会执行 dispatchBegin和dispatchEnd这两个方法。

3.1 AppMethodBeat.onStart()

下来我们继续看AppMethodBeat是怎么工作的

 public void onStart() {
        synchronized (statusLock) {
            //如果没有启动 或者已经过期 则进行启动
            if (status < STATUS_STARTED && status >= STATUS_EXPIRED_START) {
                //取消 启动过期 检查的 Runnable
                sHandler.removeCallbacks(checkStartExpiredRunnable);
                if (sBuffer == null) {
                    throw new RuntimeException(TAG + " sBuffer == null");
                }
                MatrixLog.i(TAG, "[onStart] preStatus:%s", status, Utils.getStack());
                //标示已将 启动
                status = STATUS_STARTED;
            } else {
                MatrixLog.w(TAG, "[onStart] current status:%s", status);
            }
        }
    }

onStart()主要是将AppMethodBeat 的当前状态设置为STATUS_STARTED。AppMethodBeat 中各个状态含义及触发时机可查看【附录.2】

3.2 AppMethodBeat.onStop()

    public void onStop() {
        synchronized (statusLock) {
            //进行关闭
            if (status == STATUS_STARTED) {
                MatrixLog.i(TAG, "[onStop] %s", Utils.getStack());
                status = STATUS_STOPPED;
            } else {
                MatrixLog.w(TAG, "[onStop] current status:%s", status);
            }
        }
    }

onStop()主要是将AppMethodBeat 的当前状态设置为STATUS_STOPPED。

3.3 AppMethodBeat.i()

在最开始描述AppMethodBeat类的时候，提到过在编译器会将AppMethodBeat的i(),o(),at()方法插桩到指定位置那么我们就来看看，这三个方法具体过了那些工作

   public static void i(int methodId) {
        ....
        //第一次执行该方法时 调用 realExecute 方法，并将状态切换为 STATUS_READY
        if (status == STATUS_DEFAULT) {
            synchronized (statusLock) {
                if (status == STATUS_DEFAULT) {
                    //当 当前类 没有被启动时 执行该方法 详见【3.4】
                    realExecute();
                    //切换状态 为 STATUS_READY
                    status = STATUS_READY;
                }
            }
        }

        long threadId = Thread.currentThread().getId();
        //执行回调
        if (sMethodEnterListener != null) {
            sMethodEnterListener.enter(methodId, threadId);
        }

        //如果是主线程
        if (threadId == sMainThreadId) {

            //i方法被重复执行的 提醒
            if (assertIn) {
                android.util.Log.e(TAG, "ERROR!!! AppMethodBeat.i Recursive calls!!!");
                return;
            }
            assertIn = true;
            if (sIndex < Constants.BUFFER_SIZE) {
                //详见【3.9】
                mergeData(methodId, sIndex, true);
            } else {
                sIndex = 0;
                mergeData(methodId, sIndex, true);
            }
            ++sIndex;
            assertIn = false;
        }
    }

在第一次进入i()的时候会触发调用realExecute()方法进行一些初始化工作，然后调用mergeData()方法保持调用时的methodId和时间到sBuffer中

3.4 AppMethodBeat.realExecute()

 //这个方法只有 在第一次执行 i方法时才会被调用
    private static void realExecute() {
        MatrixLog.i(TAG, "[realExecute] timestamp:%s", System.currentTimeMillis());

        //当前时间减去上一个 记录的时间 (更新 sCurrentDiffTime)
        sCurrentDiffTime = SystemClock.uptimeMillis() - sDiffTime;

        //清空 sHandler 所有消息
        sHandler.removeCallbacksAndMessages(null);
        //延迟5 ms 后执行 sUpdateDiffTimeRunnable ,开始刷新  sCurrentDiffTime 详见【3.5】
        sHandler.postDelayed(sUpdateDiffTimeRunnable, Constants.TIME_UPDATE_CYCLE_MS);
        //延迟15 ms 后执行 checkStartExpiredRunnable (检查 AppMethodBeat 当前状态的 runnable )
        //也就是 在 realExecute 方法之后后 如果 15ms 内 AppMethodBeat 还没有被启动（onStart）
        // 就将 AppMethodBeat的状态置为 STATUS_EXPIRED_START（启动过期）
        // 启动过期 只是一种状态，并不会影响 AppMethodBeat 的运行
        sHandler.postDelayed(checkStartExpiredRunnable = new Runnable() {
            @Override
            public void run() {
                synchronized (statusLock) {
                    MatrixLog.i(TAG, "[startExpired] timestamp:%s status:%s", System.currentTimeMillis(), status);
                    if (status == STATUS_DEFAULT || status == STATUS_READY) {
                        status = STATUS_EXPIRED_START;
                    }
                }
            }
        }, Constants.DEFAULT_RELEASE_BUFFER_DELAY);

        //hook 主线程的 HandlerCallback 详见【3.6】
        ActivityThreadHacker.hackSysHandlerCallback();
        //注册 looperMonitorListener 使可以接收到looper分发massage事件 详见【3.8】
        LooperMonitor.register(looperMonitorListener);
    }

3.5 AppMethodBeat.sUpdateDiffTimeRunnable

 private static Runnable sUpdateDiffTimeRunnable = new Runnable() {
        @Override
        public void run() {
            try {
                //无限循环  当isPauseUpdateTime=false（dispatchBegin方法完成）,然后更新 sCurrentDiffTime
                while (true) {
                    while (!isPauseUpdateTime && status > STATUS_STOPPED) {
                        sCurrentDiffTime = SystemClock.uptimeMillis() - sDiffTime;
                       SystemClock.sleep(Constants.TIME_UPDATE_CYCLE_MS);
                    }
                    synchronized (updateTimeLock) {
                        updateTimeLock.wait();
                    }
                }
            } catch (InterruptedException e) {
                MatrixLog.e(TAG, "" + e.toString());
            }
        }
    };

对于这个Runnable Matrix的wiki中有介绍，其中这样描述到：

考虑到每个方法执行前后都获取系统时间（System.nanoTime）会对性能影响比较大，而实际上，单个函数执行耗时小于 5ms 的情况，对卡顿来说不是主要原因，可以忽略不计，如果是多次调用的情况，则在它的父级方法中可以反映出来，所以为了减少对性能的影响，通过另一条更新时间的线程每 5ms 去更新一个时间变量，而每个方法执行前后只读取该变量来减少性能损耗。

3.6 ActivityThreadHacker.hackSysHandlerCallback()

public static void hackSysHandlerCallback() {
        try {
            //当前方法加载的时间 被认为是 APP启动时间，
            sApplicationCreateBeginTime = SystemClock.uptimeMillis();
            //记录这第一个方法，
            sApplicationCreateBeginMethodIndex = AppMethodBeat.getInstance().maskIndex("ApplicationCreateBeginMethodIndex");

            //替换 ActivityThread 中handler的 callBack 方法
            Class<?> forName = Class.forName("android.app.ActivityThread");
            Field field = forName.getDeclaredField("sCurrentActivityThread");
            field.setAccessible(true);
            //获得 ActivityThread 对象
            Object activityThreadValue = field.get(forName);
            Field mH = forName.getDeclaredField("mH");
            mH.setAccessible(true);
            //获得handler对象
            Object handler = mH.get(activityThreadValue);
            Class<?> handlerClass = handler.getClass().getSuperclass();
            Field callbackField = handlerClass.getDeclaredField("mCallback");
            callbackField.setAccessible(true);
            //获得 Handler.Callback 对象
            Handler.Callback originalCallback = (Handler.Callback) callbackField.get(handler);
            //详见【3.7】
            HackCallback callback = new HackCallback(originalCallback);
            //设置新的callback对象
            callbackField.set(handler, callback);
            MatrixLog.i(TAG, "hook system handler completed. start:%s SDK_INT:%s", sApplicationCreateBeginTime, Build.VERSION.SDK_INT);
        } catch (Exception e) {
            MatrixLog.e(TAG, "hook system handler err! %s", e.getCause().toString());
        }
    }

这个方法有两个主要作用

1. 记录sApplicationCreateBeginTime这个时间，这个时间被认为是APP启动时间。
   因为在插桩的过程中忽略了 android包下的所有类，所以运行期起一个执行 AppMethodBeat.i方法的应该是 Application的attachBaseContext方法（如果有），下来就是onCreate()方法。所以这个时间被认为是APP启动时间是没有毛病的。
2. hookActivityThread中mH的Handler.Callback对象为自定义的HackCallback对象主要用来记录最近一个Activity被打开的时间

3.7 ActivityThreadHacker.HackCallback.handleMessage()

 public boolean handleMessage(Message msg) {

            if (!AppMethodBeat.isRealTrace()) {
                //将 handleMessage 的控制权交还给 mOriginalCallback,再一次感叹真细啊，哈哈
                return null != mOriginalCallback && mOriginalCallback.handleMessage(msg);
            }
            //是否是打开activity的handler信息
            boolean isLaunchActivity = isLaunchActivity(msg);
             .....
            //打开一次activity，就记录一次数据
            if (isLaunchActivity) {
                ActivityThreadHacker.sLastLaunchActivityTime = SystemClock.uptimeMillis();
                ActivityThreadHacker.sLastLaunchActivityMethodIndex = AppMethodBeat.getInstance().maskIndex("LastLaunchActivityMethodIndex");
            }

            if (!isCreated) {
                if (isLaunchActivity || msg.what == CREATE_SERVICE || msg.what == RECEIVER) { // 如果是启动activity、service，receiver
                    //发送启动Activity等消息，认为是Application 启动的结束时间
                    ActivityThreadHacker.sApplicationCreateEndTime = SystemClock.uptimeMillis();
                    ActivityThreadHacker.sApplicationCreateScene = msg.what;
                    isCreated = true;
                }
            }

            //将 handleMessage 的控制权交还给 mOriginalCallback
            return null != mOriginalCallback && mOriginalCallback.handleMessage(msg);
        }

该方法的主要租用也有两个

1. 记录最近一个Activity的启动时间
2. 第一次进入时 记录 Application 的 启动结束时间

3.8 AppMethodBeat.looperMonitorListener

    private static LooperMonitor.LooperDispatchListener looperMonitorListener = new LooperMonitor.LooperDispatchListener() {
        @Override
        public boolean isValid() {
            return status >= STATUS_READY;
        }

        @Override
        public void dispatchStart() {
            super.dispatchStart();
            AppMethodBeat.dispatchBegin();
        }

        @Override
        public void dispatchEnd() {
            super.dispatchEnd();
            AppMethodBeat.dispatchEnd();
        }
    };

 private static void dispatchBegin() {
        //更新 sCurrentDiffTime
        sCurrentDiffTime = SystemClock.uptimeMillis() - sDiffTime;
        isPauseUpdateTime = false;
        SystemClock.uptimeMillis(),sCurrentDiffTime);
        synchronized (updateTimeLock) {
            updateTimeLock.notify();
        }
    }

    private static void dispatchEnd() {
        isPauseUpdateTime = true;
    }

上面我们已经了解过 LooperMonitor可以感知到主线程Looper开始分发和结束分发Message的实际，AppMethodBeat注册looperMonitorListener监听到 LooperMonitor主要是 为了在主线程空闲的情况下停止更新sCurrentDiffTime在主线程开始工作时再开始更新sCurrentDiffTime以减少资源的占用。

3.9 AppMethodBeat.mergeData()

   private static void mergeData(int methodId, int index, boolean isIn) {
        if (methodId == AppMethodBeat.METHOD_ID_DISPATCH) {//如果是 handler 的 dispatchMessage 方法
            sCurrentDiffTime = SystemClock.uptimeMillis() - sDiffTime;
        }
        // 合并后的数据存到 trueId中
        long trueId = 0L;
        if (isIn) {//如果是 i 方法 则第63位上是1，否则为0 （就是一个标志位）
            trueId |= 1L << 63;
        }
        //43-62位 存储 methodId
        trueId |= (long) methodId << 43;
        //0-42位存储 sCurrentDiffTime
        trueId |= sCurrentDiffTime & 0x7FFFFFFFFFFL;
        //存放到 sBuffer中
        sBuffer[index] = trueId;
        checkPileup(index);
        sLastIndex = index;
    }

这个方法的第三个参数isIn的含义为是否是 i()方法，i()方法中被调用为 trueo()方法中被调用为false。

mergeData其实就做了一件事，就是将方法类型（i或o），methodId,sCurrentDiffTime存到sBuffer中的index位置

3.10 AppMethodBeat.o()

    public static void o(int methodId) {
        //对 AppMethodBeat 状态进行检查
        if (status <= STATUS_STOPPED) {
            return;
        }
        //对 methodId进行校验
        if (methodId >= METHOD_ID_MAX) {
            return;
        }

        //如果是主线程
        if (Thread.currentThread().getId() == sMainThreadId) {
            if (sIndex < Constants.BUFFER_SIZE) {
                mergeData(methodId, sIndex, false);
            } else {
                sIndex = 0;
                mergeData(methodId, sIndex, false);
            }
            ++sIndex;
        }
    }

和i()方法一样最终也是调用了mergeData()来存储数据到sBuffer中

3.11 AppMethodBeat.at()

    public static void at(Activity activity, boolean isFocus) {
        String activityName = activity.getClass().getName();
        if (isFocus) {
            //获取焦点的activity 添加到 sFocusActivitySet
            if (sFocusActivitySet.add(activityName)) {
                synchronized (listeners) {
                    //广播 activityName 获取到焦点
                    for (IAppMethodBeatListener listener : listeners) {
                        listener.onActivityFocused(activityName);
                    }
                }
                // activity 不都有了吗 为啥还要通过 getVisibleScene() 获取？
                MatrixLog.i(TAG, "[at] visibleScene[%s] has %s focus!", getVisibleScene(), "attach");
            }
        } else {
            //失去焦点的activity 从sFocusActivitySet移除
            if (sFocusActivitySet.remove(activityName)) {
                MatrixLog.i(TAG, "[at] visibleScene[%s] has %s focus!", getVisibleScene(), "detach");
            }
        }
    }

在刚开始我们描述AppMethodBeat这个类的时候提到过，它能感知到某个activity是否获取到焦点。这是因为at()方法会在编译器被插入到 Activity的onWindowFocusChanged()方法中。

at()方法主要的功能是自己获得的焦点信息分发给每一个IAppMethodBeatListener

3.12 AppMethodBeat.realRelease()

    static {
        //在 AppMethodBeat 类加载 15s 后，还没有使用（status的状态还是STATUS_DEFAULT），就清空AppMethodBeat 占用的内存
        sHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                realRelease();
            }
        }, Constants.DEFAULT_RELEASE_BUFFER_DELAY);
    }

    private static void realRelease() {
        synchronized (statusLock) {
            if (status == STATUS_DEFAULT) {
                MatrixLog.i(TAG, "[realRelease] timestamp:%s", System.currentTimeMillis());
                sHandler.removeCallbacksAndMessages(null);
                //移除 looperMonitorListener 监听
                LooperMonitor.unregister(looperMonitorListener);
                //sTimerUpdateThread 退出
                sTimerUpdateThread.quit();
                sBuffer = null;
                //状态改为 STATUS_OUT_RELEASE
                status = STATUS_OUT_RELEASE;
            }
        }
    }

这个方法主要是在 AppMethodBeat 类加载 15s 后，还没有使用的情况下释放各种资源，尤其是sBuffer因为它就占用了7.6M的内存。

总结

1. UIThreadMonitor配合LooperMonitor获得每个刷新帧的各个阶段的耗时时间
2. AppMethodBeat中记录了Application的启动时间和结束，Activity的启动时间和结束，每个方法的耗时时间。

系列文章

• 腾讯 Apm 框架 Matrix 源码阅读 - gradle插件
• 腾讯 Apm 框架 Matrix 源码阅读 - 架构解析
• 腾讯 Apm 框架 Matrix 源码阅读 - TracePlugin 架构解析
• 腾讯 Apm 框架 Matrix 源码阅读 - TracePlugin 之 FrameTracer
• 腾讯 Apm 框架 Matrix 源码阅读 - TracePlugin 之 StartupTracer
• 腾讯 Apm 框架 Matrix 源码阅读 - TracePlugin 之 AnrTracer
• 腾讯 Apm 框架 Matrix 源码阅读 - TracePlugin 之 上报字段含义

参考资料

• 推荐 Matrix 源码完整注释
  
• Matrix Android TraceCanary
  
• Matrix源码分析-Trace Canary
  

附录

1. LooperObserver中各个参数的含义

 /**
     *
     * @param beginMs dispatch 的起始时间
     * @param cpuBeginMs dispatch 的起始时 当前线程时间
     * @param token 等于 dispatch 的起始时间
     */
    @CallSuper
    public void dispatchBegin(long beginMs, long cpuBeginMs, long token) {
        isDispatchBegin = true;
    }

    /**
     *
     * @param focusedActivityName 当前activity的名字
     * @param start looper dispatch 的起始时间
     * @param end looper dispatch 的结束时间
     * @param frameCostMs 该帧耗时
     * @param inputCostNs input 花费 时间
     * @param animationCostNs animation 花费 时间
     * @param traversalCostNs traversal 花费 时间
     */
    public void doFrame(String focusedActivityName, long start, long end, long frameCostMs, long inputCostNs, long animationCostNs, long traversalCostNs) {

    }

    /**
     *
     * @param beginMs dispatch 的起始时间
     * @param cpuBeginMs dispatch 的起始时 当前线程时间
     * @param endMs dispatch 的结束时间
     * @param cpuEndMs dispatch 的结束时 当前线程时间
     * @param token 等于 dispatch 的起始时间
     * @param isBelongFrame 是否属于一帧？ 不确定
     */
    @CallSuper
    public void dispatchEnd(long beginMs, long cpuBeginMs, long endMs, long cpuEndMs, long token, boolean isBelongFrame) {
        isDispatchBegin = false;
    }

2. AppMethodBeat中各个状态含义及触发时机可查看

    //默认状态
    private static final int STATUS_DEFAULT = Integer.MAX_VALUE;
    //调用onStart()后的状态
    private static final int STATUS_STARTED = 2; //启动
    //第一次 执行 i 方法后的状态
    private static final int STATUS_READY = 1; // 准备好
    //调用onStop()后的状态
    private static final int STATUS_STOPPED = -1; //停止
    //启动已过期 当 在 realExecute 方法之后后 如果 15ms 内 AppMethodBeat 还没有被启动（onStart）就会被置为这种状态
    private static final int STATUS_EXPIRED_START = -2;
    //在 AppMethodBeat 类加载 15s 后，还没有使用（status的状态还是STATUS_DEFAULT），就会被置为这种状态
    private static final int STATUS_OUT_RELEASE = -3;//已释放