Matrix源码分析系列-如何计算启动耗时（一）-阿里云开发者社区

什么是启动耗时

分为两个角度：

冷启动：就是点击应用图标到打开应用的冷启动响应时间，且前提是应用从未被创建过进程，
热启动：测量点击应用图标到打开应用的热启动响应时间，被测应用之前已经被打开过，无关闭应用行为，测试时被重新切换到前台

启动耗时影响什么

第一想到的肯定是用户体验，如果你的应用半分钟没有启动起来，那谁还想用呢？所以很多大厂App，虽然一个App承载的业务多的数不胜数，但肯定都有一个特点，一点就开，即开即用。

启动耗时的标准是什么

各类应用的冷启动时间应≤2000毫秒、游戏类应用和影音娱乐类应用冷启动时间≤3000毫秒，各类应用的热启动时间应≤500毫秒、游戏类应用和影音娱乐类应用冷启动时间≤1000毫秒。同样来源于软件绿色联盟应用体验标准3.0——性能标准，请点击链接查看详情。

如何查看启动耗时呢

其实查看启动耗时，官方已经给我提供了很多工具，如TraceView，我们就可以通过它来查看图形执行时间，调用栈等，但是它的缺点也很明显，运行时开销严重，得出的结果并不真实，同样的我们还可以借助android studio terminal，来一个简单的测试，如下：

命令：

adb shell am start -W [packageName]/[AppstartActivity全路径]

可以看到，我用同一个命令，测试了两次，第一次是应用进程存活时，LaunchState是HOT，TotalTime就是启动耗时，WaitTime是AMS启动Activity的总耗时，包括创建进程 + Application初始化 + Activity初始化到界面显示的过程。第二次的冷启动低于500ms，还算是比较合理的，热启动在115ms，是不是很优秀，其实这个应用不具有代表性，因为是测试Demo，代码比较简单，所以启动很快，对于一些大型引用肯定就不是这样了，虽然这种方式可以很快的拿到指标数据，但有个缺点你会发现，即使我知道了耗时，如果出现耗时不正常的操作，就不知道哪里出现的问题。所以我就想，是不是Matrix能解决这些问题呢，待我们去验证。我们还是不着急去看Matrix的源码，我们先来看下如何通过代码实现一个启动耗时统计，除了以上方法，google还给我们提供了Systrace 命令行工具，可以结合代码插桩一起完成耗时分析，插桩就是在需要监听的方法前后，插入一行代码。 最新消息google 在Android 10 中引入的全新平台级跟踪工具Perfetto，具体请看developer.android.com/topic/perfo…，具体可以理解为Systrace的升级版本，我们现在不研究这些工具，先来看看，我们如何通过代码插桩的方式来监控应用的启动耗时。插桩也是Matrix实现的核心，所以我们仔细聊聊。

需要监控的函数

既然我们决定使用代码的插桩来实现，那么就需要知道对哪些函数做操作，具体什么函数，这要看App整个启动过程的函数调用顺序，我整理了几个流程图，请看：

大致流程就是这样，并没有特别详细，基本原理给大家搞清楚，然后知道函数的调用顺序就ok，从图中分析出的知识点：

包括SystemServer在内，我们的app也都是zygote进程fork出来的
当别人通过startActivity启动我们的app时，其实是ActivityManagerService通过startProcessLocked告知zygote进程
当app进程被创建后，进程中会创建出ActivityThread，通过源码我们发现ActivityThread中有个java的main函数，main函数调用attach函数，如图

attach函数通过binder又返回到ActivityManagerService中，再由ActivityManagerService调用attachApplicationLocked，然后再通过binder调到ApplicationThread.bindApplication，ApplicationThread是ActivityThread中的私有类，如图

ApplicationThread 通过handler message通信，最终调用ActivityThread的handleBindApplication函数，然后在该方法中根据拿到的appInfo信息，创建appContext，最后创建Application，调用application的onCreate函数。
Activity的创建通过ActivityStackSupervisor.realStartActivityLocked，最终通过binder，在ActivityThread中执行handleLaunchActivity，紧接着attach到对应的上下文中。

从这张图中，我们了解了App的启动过程，其实在Android不同的SDK版本中都有升级，会导致部分代码找不到，但大同小异。我们的目的其实是为了找到插桩的地方，且有一点我们用到的插桩是java字节码，所以有binder通信的地方，我们只能改动java层的代码，所以基本可以敲定，插桩代码就是在我们的App进程中。

简单定义一个计算公式： App的启动耗时 = 第一个Activity创建好的时间 - Application onCreate 时间

当然有的app是启动页+Home主页才算是app启动完成，这里先不纠结这个，我们现在已经可以明确的点，Application onCreate方法和 Activity的相关方法（后面再分析哪个方法更合适）都是我们要插桩的点。那么接下来我们简单说下插桩的几个框架，来看看哪个更加合适。

插桩方案选择哪个？AspectJ、ASM、ReDex

AspectJ 和 ASM 框架是我们最常用的 Java 字节码处理框架。AspectJ是 Java 中流行的 AOP（aspect-oriented programming）编程扩展框架，从使用上来看，作为字节码处理元老，AspectJ 的框架的确有自己的一些优势，但官方建议切换到 ObjectWeb 的 ASM 框架，而ReDex是 Facebook 开源的工具，通过对字节码进行优化，以减小 Android Apk 大小，同时提高 App 启动速度。ReDex 里甚至提供了 Method Tracing 和 Block Tracing 工具，可以在所有方法或者指定方法前面插入一段跟踪代码。我们为什么不用它呢，因为Matrix用的ASM，并且ASM可以实现 100% 场景的 Java 字节码操作，已经满足了我们的需求。那么接下来，我们用ASM来实现一个代码插桩用例。

ASM实现插桩用例

我们的目标是给Android的某个类，做函数插桩，下面我们做一个demo作为本次的用例，带你有序的了解，该如何通过ASM做函数插桩。

1.Demo项目创建

这一步不用多说，直接在Android Studio中，new project 就行，等待项目第一次编译完成

2.gradle插件创建

在项目的根目录中，创建buildSrc文件夹，然后构建一下项目，然后在buildSrc文件夹中创建build.gradle配置文件，如下：

plugins{
    //使用 java groovy 插件
    id 'java'
    id 'groovy'
}
group 'com.julive.sam'
version '0.0.1'
sourceCompatibility = 1.8
repositories{
    //使用阿里云的maven代理
    maven { url 'https://maven.aliyun.com/repository/google' }
    maven { url 'https://maven.aliyun.com/repository/public' }
    maven {
        url 'http://maven.aliyun.com/nexus/content/groups/public/'
    }
    maven {
        url 'http://maven.aliyun.com/nexus/content/repositories/jcenter'
    }
}
def asmVersion = '8.0.1'
dependencies {
  //引入gradle api
    implementation gradleApi()
    implementation localGroovy()
    //引入android studio扩展gradle的相关api
    implementation "com.android.tools.build:gradle:4.1.0"
    //引入apache io
    implementation 'org.apache.directory.studio:org.apache.commons.io:2.4'
    //引入ASM相关api，这是我们插桩的关键，要靠他实现方法插桩
    implementation "org.ow2.asm:asm:$asmVersion"
    implementation "org.ow2.asm:asm-util:$asmVersion"
    implementation "org.ow2.asm:asm-commons:$asmVersion"
}

接下来创建插件代码目录，由于我们使用java写的插件，所以需要选中buildSrc，然后鼠标右键选择new，再选择directory，最后出现的对话框中选择 src/main/java，下图中是因为我的项目已经创建完了，所以只有groovy目录，如果你需要写groovy的实现就创建下图中文件夹路径，创建完这个下一步就是创建插件。

在java目录中，创建包名com.julive.sam，在该包路径下创建Plugins插件，代码如下：

public class Plugins implements Plugin<Project> {
    @Override
    public void apply(Project target) {
    }
}

然后创建插件的配置resources文件夹，和java文件夹同级，在resources下创建文件夹META-INF/gradle-plugins/，最终在gradle-plugins中创建com.julive.sam.properties，意思是你的包名.properties ，一定要对应好包名，然后在该文件中加入代码

implementation-class=com.julive.sam.Plugins

com.julive.sam.Plugins 你点击后，看能否跳转至上面创建的Plugins插件中，如果可以直接跳转那就ok了。

3.下一步在App的build.gradle中配置插件

4.创建gradle的Transform实现

Transform是在.class -> .dex转换期间，用来修改.class文件的一套标准API，所以你现在应该知道了，在transform中我们肯定要调用ASM的实现，来实现.class文件的修改，最终转换为.dex文件。创建Transform的实现如下：

public class TransformTest extends Transform {
    @Override
    public String getName() {
        // 随便起个名字
        return "TransformSam";
    }
    @Override
    public Set<QualifiedContent.ContentType> getInputTypes() {
        //代表处理的 java 的 class 文件
        return TransformManager.CONTENT_CLASS; 
    }
    @Override
    public Set<? super QualifiedContent.Scope> getScopes() {
        //要处理所有的class字节码
        return TransformManager.SCOPE_FULL_PROJECT;
    }
    @Override
    public boolean isIncremental() {
        // 是否增量编译，我们先不考虑，返回false
        return false; 
    }
    @Override
    public void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
        super.transform(transformInvocation);
        try {
            //待实现
            doTransform(transformInvocation); // hack
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

看上面注释是不是就对Transform有了一定的了解呢，那么如何处理.class文件呢？我们来实现doTransform函数，来看如何处理

private void doTransform(TransformInvocation transformInvocation) throws IOException {
        System.out.println("doTransform   =======================================================");
        //inputs中是传过来的输入流，其中有两种格式，一种是jar包格式一种是目录格式。
        Collection<TransformInput> inputs = transformInvocation.getInputs();
        //获取到输出目录，最后将修改的文件复制到输出目录，这一步必须做不然编译会报错
        TransformOutputProvider outputProvider = transformInvocation.getOutputProvider();
        //删除之前的输出
        if (outputProvider != null)
            outputProvider.deleteAll();
        inputs.forEach(transformInput -> {
            //遍历directoryInputs
            transformInput.getDirectoryInputs().forEach(directoryInput -> {
            });
            //jarInputs
            transformInput.getJarInputs().forEach(jarInput -> {
            });
        });
    }

从transformInvocation的api中，我们获取了两个东西，一个是inputs，一个是outputProvider，我们遍历inputs后发现，他有两个api getDirectoryInputs和getJarInputs 这俩是什么东西呢？我描述不太好，我加了日志，来看下日志输出：

这下是不是看明白了，其实我对getDirectoryInputs做了一层文件筛选处理

transformInput.getDirectoryInputs().forEach(directoryInput -> {
      ArrayList<File> list = new ArrayList<>();
      getFileList(directoryInput.getFile(), list);
});
  //递归查找该文件夹下所有文件，因为我们修改的是.class 文件，而不关系文件夹
   void getFileList(File file, ArrayList<File> fileList) {
        if (file.isFile()) {
            fileList.add(file);
        } else {
            File[] list = file.listFiles();
            for (File value : list) {
                getFileList(value, fileList);
            }
        }
    }

好，从上面我们看出，已经找到了MainActivity的class文件，那么接下来给MainActivity.class的onCreate函数，插入两行代码，

5.现在开始操作ASM的api

首先要实现ASM的 ClassVisitor 类来操作我们想要操作的类，它可以访问class文件的各个部分，比如方法、变量、注解等

基本的实现如下：

public class TestClassVisitor extends ClassVisitor{
    private String className;
    private String superName;
    TestClassVisitor(final ClassVisitor classVisitor) {
        super(Opcodes.ASM6, classVisitor);
    }
    /**
     * 这里可以拿到关于.class的所有信息，比如当前类所实现的接口类表等
     *
     * @param version    表示jdk的版本
     * @param access     当前类的修饰符 （这个和ASM 和 java有些差异，比如public 在这里就是ACC_PUBLIC）
     * @param name       当前类名
     * @param signature  泛型信息
     * @param superName  当前类的父类
     * @param interfaces 当前类实现的接口列表
     */
    @Override
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
        super.visit(version, access, name, signature, superName, interfaces);
        this.className = name;
        this.superName = superName;
    }
    @Override
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
        //委托函数
        MethodVisitor methodVisitor = cv.visitMethod(access, name, descriptor, signature, exceptions);
        //找到我们需要修改的类，注意这里是/ 斜杠来表示文件的路径，并不是java代码中的.
        if (className.equals("com/julive/samtest/MainActivity")) {
            // 判断方法name是onCreate
            if (name.startsWith("onCreate")) {
                //插桩函数的实现，同样用到ASM提供的对象，下面看具体实现代码
                return new TestMethodVisitor(Opcodes.ASM6, methodVisitor, access, name, descriptor, className, superName);
            }
        }
        return methodVisitor;
    }
}

这里集成AdviceAdapter，其实AdviceAdapter是继承自MethodVisitor，这是不是就跟ClassVisitor一一呼应呢，使用它是因为它比较方便的实现，提供了onMethodEnter，onMethodExit，正好是我们的需求。在onCreate的函数的前后各插入一行代码。但仔细看onMethodEnter的函数实现，你会发现一脸懵逼，不知道是啥玩意。往下看

public class TestMethodVisitor extends AdviceAdapter {
    private String className;
    private String superName;
    protected TestMethodVisitor(int i, MethodVisitor methodVisitor, int i1, String s, String s1,String className,String superName) {
        super(i, methodVisitor, i1, s, s1);
        this.className = className;
        this.superName = superName;
    }
    @Override
    protected void onMethodEnter() {
        super.onMethodEnter();
        mv.visitLdcInsn("TAG");
        mv.visitLdcInsn(className + "---->" + superName);
        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "android/util/Log", "i", "(Ljava/lang/String;Ljava/lang/String;)I", false);
        mv.visitInsn(Opcodes.POP);
    }
    @Override
    protected void onMethodExit(int opcode) {
        mv.visitLdcInsn("TAG");
        mv.visitLdcInsn("this is end");
        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "android/util/Log", "i", "(Ljava/lang/String;Ljava/lang/String;)I", false);
        mv.visitInsn(Opcodes.POP);
        super.onMethodExit(opcode);
    }
}

在这里推荐一个插件，plugins.jetbrains.com/plugin/1486…，用插件测试代码如下：

public class Test {
    void aa() {
        Log.i("TAG", "this is end");
    }
}

转换ASM代码如下：

public static byte[] dump() throws Exception {
        ClassWriter classWriter = new ClassWriter(0);
        FieldVisitor fieldVisitor;
        MethodVisitor methodVisitor;
        AnnotationVisitor annotationVisitor0;
        classWriter.visit(V1_8, ACC_PUBLIC | ACC_SUPER, "com/julive/samtest/Test", null, "java/lang/Object", null);
        classWriter.visitSource("Test.java", null);
        {
            methodVisitor = classWriter.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
            methodVisitor.visitCode();
            Label label0 = new Label();
            methodVisitor.visitLabel(label0);
            methodVisitor.visitLineNumber(5, label0);
            methodVisitor.visitVarInsn(ALOAD, 0);
            methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
            methodVisitor.visitInsn(RETURN);
            Label label1 = new Label();
            methodVisitor.visitLabel(label1);
            methodVisitor.visitLocalVariable("this", "Lcom/julive/samtest/Test;", null, label0, label1, 0);
            methodVisitor.visitMaxs(1, 1);
            methodVisitor.visitEnd();
        }
        {
            methodVisitor = classWriter.visitMethod(0, "aa", "()V", null, null);
            methodVisitor.visitCode();
            Label label0 = new Label();
            methodVisitor.visitLabel(label0);
            methodVisitor.visitLineNumber(8, label0);
            methodVisitor.visitLdcInsn("TAG");
            methodVisitor.visitLdcInsn("this is end");
            methodVisitor.visitMethodInsn(INVOKESTATIC, "android/util/Log", "i", "(Ljava/lang/String;Ljava/lang/String;)I", false);
            methodVisitor.visitInsn(POP);
            Label label1 = new Label();
            methodVisitor.visitLabel(label1);
            methodVisitor.visitLineNumber(9, label1);
            methodVisitor.visitInsn(RETURN);
            Label label2 = new Label();
            methodVisitor.visitLabel(label2);
            methodVisitor.visitLocalVariable("this", "Lcom/julive/samtest/Test;", null, label0, label2, 0);
            methodVisitor.visitMaxs(2, 1);
            methodVisitor.visitEnd();
        }
        classWriter.visitEnd();
        return classWriter.toByteArray();
    }

是不是很长，哈哈，这段代码其实是将整个Test类的东西，都通过ASM的方式生成，我们只需要找到对应的日志如下：

methodVisitor.visitLdcInsn("TAG");
   methodVisitor.visitLdcInsn("this is end");
   methodVisitor.visitMethodInsn(INVOKESTATIC, "android/util/Log", "i", "(Ljava/lang/String;Ljava/lang/String;)I", false);
   methodVisitor.visitInsn(POP);

然后将其放入到onMethodExit函数中，就可以了。

6.Tranfrom结合ASM实现

现在万事具备只欠东风，就是将Tranform拿到的class文件通过ASM做修改，具体如何关联，请看，回到刚才的doTransform中，改成如下代码：

private void doTransform(TransformInvocation transformInvocation) throws IOException {
        System.out.println("doTransform   =======================================================");
        //inputs中是传过来的输入流，其中有两种格式，一种是jar包格式一种是目录格式。
        Collection<TransformInput> inputs = transformInvocation.getInputs();
        //获取到输出目录，最后将修改的文件复制到输出目录，这一步必须做不然编译会报错
        TransformOutputProvider outputProvider = transformInvocation.getOutputProvider();
        //删除之前的输出
        if (outputProvider != null)
            outputProvider.deleteAll();
        inputs.forEach(transformInput -> {
            //遍历directoryInputs
            transformInput.getDirectoryInputs().forEach(directoryInput -> {
                ArrayList<File> list = new ArrayList<>();
                getFileList(directoryInput.getFile(), list);
                list.forEach(file -> {
                    System.out.println("getDirectoryInputs   =======================================================" + file.getName());
                    // 判断是.class文件
                    if (file.isFile() && file.getName().endsWith(".class")) {
                        try {
                            //ASM提供的读取类信息的对象
                            ClassReader classReader = new ClassReader(new FileInputStream(file));
                            //ASM提供的类修改对象，并将读到的信息交给classWriter
                            ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS);
                            //创建修改规则，TestClassVisitor
                            ClassVisitor visitor = new TestClassVisitor(classWriter);
                            //将修改规则给classReader
                            classReader.accept(visitor, ClassReader.EXPAND_FRAMES);
                            //通过toByteArray方法，将变更后信息转成byte数组
                            byte[] bytes = classWriter.toByteArray();
                            //放入输出流中往原文件中写入
                            FileOutputStream fileOutputStream = new FileOutputStream(file.getAbsolutePath());
                            fileOutputStream.write(bytes);
                            fileOutputStream.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                });
                if (outputProvider != null) {
                    File dest = outputProvider.getContentLocation(directoryInput.getName(), directoryInput.getContentTypes(), directoryInput.getScopes(), Format.DIRECTORY);
                    try {
                        //将该文件放入到目标目录中，这步骤必须实现，否则会导致dex文件找不到该文件
                        FileUtils.copyDirectory(directoryInput.getFile(), dest);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
            //jarInputs
            transformInput.getJarInputs().forEach(jarInput -> {
                ArrayList<File> list = new ArrayList<>();
                getFileList(jarInput.getFile(), list);
                list.forEach(file -> {
                    System.out.println("getJarInputs   =======================================================" + file.getName());
                });
                if (outputProvider != null) {
                    File dest = outputProvider.getContentLocation(
                            jarInput.getName(),
                            jarInput.getContentTypes(),
                            jarInput.getScopes(),
                            Format.JAR);
                    //将该文件放入到目标目录中，这步骤必须实现，否则会导致dex文件找不到该文件
                    try {
                        FileUtils.copyFile(jarInput.getFile(), dest);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        });
    }

Matrix源码分析系列-如何计算启动耗时（一）

什么是启动耗时

启动耗时影响什么

启动耗时的标准是什么

如何查看启动耗时呢

需要监控的函数

插桩方案选择哪个？AspectJ、ASM、ReDex

ASM实现插桩用例

1.Demo项目创建

2.gradle插件创建

3.下一步在App的build.gradle中配置插件

4.创建gradle的Transform实现

5.现在开始操作ASM的api

6.Tranfrom结合ASM实现

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Matrix源码分析系列-如何计算启动耗时（一）

什么是启动耗时

启动耗时影响什么

启动耗时的标准是什么

如何查看启动耗时呢

需要监控的函数

插桩方案选择哪个？AspectJ、ASM、ReDex

ASM实现插桩用例

1.Demo项目创建

2.gradle插件创建

3.下一步在App的build.gradle中配置插件

4.创建gradle的Transform实现

5.现在开始操作ASM的api

6.Tranfrom结合ASM实现

热门文章

最新文章

相关电子书