HAHA库实现原理剖析

1.前提

本文将以讲解原理为主，部分代码讲解，可以自行下载HAHA库源码进行对照学习。

implementation 'com.squareup.haha:haha:2.0.3'

如果你看过Leakcanary2.0之前的源码，你应该会熟悉HAHA库，它是一个解析hrpof文件的库，通过它我们可以获得当前内存的对象信息，包括如下信息。

1.获得对象的shallow size和retained size。

2.获得对象的引用链。

2.HAHA库的实现步骤：

1.Hprof（堆转存）文件的解析。

2.支配树的构造和Retained Size计算。

3.最短路径构建。

下面我将会从这几个主要维度进行介绍。

2.1 Hprof（堆转存）文件的解析。

    Hprof是一份存储了当前时刻内存信息的文件，即内存快照。可以方便我们进行内存分析。里面包括类信息、栈信息、堆信息。其中堆信息是需要我们关注的重点。堆信息包括了所有的对象：线程对象、类对象、实例对象、对象数组对象、原始类型数组对象。其中类对象可以获得该类的常量、静态变量、实例变量等信息。

2.1.1 Hprof 文件格式

    首先需要理解Hprof文件的格式，它的基本数据类型为u1、u2、u4、u8，分别代表1 byte、2 byte、4 byte、8 byte的内容，由文件头和文件内容（records)组成,如下图：

image

2.1.2 文件头格式如下：

长度	含义
[u1]*	以null为结尾的一串字节，表示版本号名称及相应的版本，比如JAVA PROFILE 1.0.3（一般是18byte + 1byte null字节）
u4	标识符大小，这些标识符代表UTF8的字符串、对象、堆栈等信息的id长度
u4	高位时间戳
u4	低位时间戳

2.1.3 文件头格式如下：

文件内容格式如下：

长度	含义
u1	TAG值，16进制地址，代表它是一个什么类型的信息，它是一个16进制的值，比如strings、堆信息等record
u4	时间戳
u4	LENGTH，即BODY的字节长度
[u1]*	BODY，具体内容,即上述读取出的字节长度

2.1.4 文件内容格式如下：

string的格式如下，其他信息可以自行查阅：http://hg.openjdk.java.net/jdk6/jdk6/jdk/raw-file/tip/src/share/demo/jvmti/hprof/manual.html#mozTocId848088

图片.png

2.1.5 TAG类型信息：

HPROF_TAG_STRING = 0x01；字符串信息
HPROF_TAG_LOAD_CLASS = 0x02； 可以获得类id对应的字符串信息
HPROF_TAG_STACK_FRAME = 0x04；栈帧信息
HPROF_TAG_STACK_TRACE = 0x05；栈信息
HPROF_TAG_HEAP_DUMP = 0x0C；
HPROF_TAG_HEAP_DUMP_SEGMENT = 0x1C；这2个是所有的对象信息

如果TAG是HEAP_DUMP 或 HEAP_DUMP_SEGMENT ，它的BODY由一系列子record组成
HEAP DUMP 或  HEAP DUMP SEGMENT的sub-tag信息
// Traditional. 
HPROF_ROOT_UNKNOWN = 0xFF, 
HPROF_ROOT_JNI_GLOBAL = 0x01,        // native 变量  
HPROF_ROOT_JNI_LOCAL = 0x02,  
HPROF_ROOT_JAVA_FRAME = 0x03,  
HPROF_ROOT_NATIVE_STACK = 0x04,  
HPROF_ROOT_STICKY_CLASS = 0x05,  
HPROF_ROOT_THREAD_BLOCK = 0x06,  
HPROF_ROOT_MONITOR_USED = 0x07,  
HPROF_ROOT_THREAD_OBJECT = 0x08,  
HPROF_CLASS_DUMP = 0x20,            // 类  
HPROF_INSTANCE_DUMP = 0x21,         // 实例对象  
HPROF_OBJECT_ARRAY_DUMP = 0x22,     // 对象数组  
HPROF_PRIMITIVE_ARRAY_DUMP = 0x23,  // 基础类型数组   
// Android.  
HPROF_HEAP_DUMP_INFO = 0xfe,  
HPROF_ROOT_INTERNED_STRING = 0x89,  
HPROF_ROOT_FINALIZING = 0x8a,  // Obsolete.  
HPROF_ROOT_DEBUGGER = 0x8b,  
HPROF_ROOT_REFERENCE_CLEANUP = 0x8c,  // Obsolete.  
HPROF_ROOT_VM_INTERNAL = 0x8d,  
HPROF_ROOT_JNI_MONITOR = 0x8e,  
HPROF_UNREACHABLE = 0x90,  // Obsolete.  
HPROF_PRIMITIVE_ARRAY_NODATA_DUMP = 0xc3,  // Obsolete.

2.1.6 Basic Type：

在类对象中可以获得所有实例变量的type，通过type我们即可以知道它是一个什么类型。

长度	含义
2	object
4	boolean
5	char
6	float
7	double
8	byte
9	short
10	int
11	long

通常我们关心的主要是三类信息：

1. 字符串信息：所有的字符串，包括类名、实例名、变量名等。
2. 类的结构信息：父类信息、变量布局等。
3. 堆信息：包括GC ROOT、普通对象、普通对象数组、对象之间的引用等。

2.2 GC ROOT

HAHA库就是通过上述规则读取获得类对象、实例对象、对象数组、基本类型数组、GC ROOT等信息。
在所有对象中，会有一部分虚拟机认定的GC Root。
什么是GC Root：首先我们需要了解一下JVM的垃圾回收算法，其中一个是可达性算法，可达性的意思是如果存在从一个起点到该对象的引用链，该对象就不能被回收，该起点就是GC Root。
GC Root的特点：当前时刻存活的对象！这是肯定的，只有引用是活跃的，那么它所直接引用和间接引用的对象必然是有用的，是不能被回收的。
可以被当成GC root的类型：

• Stack Local：当前活跃的栈帧中指向GC堆中的引用（局部变量、方法的引用类型参数）
• Thread：存活的线程
• JNI Local:Native栈中的局部变量
• JNI Global:Native全局引用
• Monitor Used：用于同步的监控对象
• Held by JVM：用于JVM特殊目的由GC保留的对象。包括类加载器、JVM中重要的异常类等。

3.构建支配树：

在Hprof这份文件中，将解析出来的对象之间建立一个引用与被引用的关系，然后再为所有的GC ROOT设置一个超级源点，这样就会形成一个以超级源点为根的引用树（中间可能会存在环）。

3.1 Shallow Size 和 Retained Size

3.1.1 Shallow Size：

某个对象的Shallow Size就是对象本身的大小，不包含引用的大小。
下面是对象的内存结构：包括下面几个部分：

1. 对象头：包括Mark Word和Klass Point（指针，指向方法区的Class对象信息），下面还分三种大小

1. 在32位系统下，Mark Word是4byte，指针大小是4byte，所以对象头为8byte
2. 在64位系统下，Mark Word是8byte，指针大小是8byte，所以对象头为16byte
3. 在64位系统下并开启指针压缩的情况下，Mark Word是8byte，指针大小是4byte，所以对象头为12byte

2. 实际数据：就是实例对象的类型大小，比如int，String等大小

3. 对齐填充：这个并不一定会存在，因为要求对象起始地址必须是8字节的整数倍。

   
   
   图片.png
   
   

   比如下面这个类：

public class A {
    int a;
    B b;
}

在64位系统并开启指针压缩的情况下，它的Shallow Size = 12 （对象头）+ 8（实际大小）+4（对齐填充）= 24byte。

3.1.2 Retained Size：

Retained Size的大小简单来理解就是其支配的所有节点的Shallow Size之和，这里有一个支配的节点的概念，在对象中的应用就是对象A->B->C，这中间没有任何引用指向B或者C，这就是A支配B，B支配C，A支配C。
比如下面这张图，我们来求对象A的Retained Size，对象A有实例对象B、C、D，正常来说就是B、C、D的Shallow Size之和就是它的Retained Size，但是对象D（D有可能是一个全局的实例）也被对象E所引用，所以对象D的支配点就不是A而是最顶层的O，因此对象A的Retained Size = B + C的Retained Size。

图片.png

换句话说Retained Size就是某对象被VM回收后所能释放的内存大小。
Retained Size对于内存的分析有很大的指引作用，该值大有可能是不合理的内存使用或者泄露。

3.2 支配树

再来看一下支配树的定义：对于有向图D,起点S,终点T，存在S>多条路径>T，在所有的路径中S到T必经的点称为支配点，删了该点，将不存在S到T的路径，因此称起点为S时，该点支配了T。离T点最近的支配点称为直接支配点。
S>T中可能有很多支配点，由这些支配点构成的树，称为支配树
支配树的性质：

• S为树根
• 根到树上任一点的路径经过的点均为根支配的点
  任意子树也有上述性质。
  有木有觉得和求Reatined Size的流程很像，也就是说，在求某个对象的Reatined Size，只要构建相应的支配树，然后进行其支配节点的相加即可。
  支配树的生成：
  一般来说，对于一张DAG（有向无环图）来说，可以通过拓扑序+LCA(最近公共祖先）的方法来构造支配树。但是对于实际对象的引用关系，有可能会存在环，也就是普通的有向图。下面我先介绍一下DAG构造支配树的过程：

3.3 拓扑排序

定义：它是对有向图的顶点排成一个线性序列。
在图论中，拓扑排序是一个有向无环图（DAG）的所有顶点的线性序列。且满足下面两个条件：

• 每个顶点出现且只出现一次。
• 若存在一条从顶点A到顶点B的路径，那么在序列中顶点A出现在顶点B的前面。

• 拓扑序可以有多个。
  拓扑序的求得方式可以自行查资料，我这里只说结果。求拓扑序中第x点的直接支配点时，该x点前的直接支配点已经求得完成，也就是支配树已经构造好，这时候就可以对点x的所有父亲求LCA求得直接支配点。举个例子，对于下图（数字代表求好的拓扑序号）：

  
  
  图片.png
  
  

  比如我们现在想求7的直接支配点，则说明1-6的支配树已经构造完成，只需要求7所有父类的LCA即可
  。即下图：

  
  
  图片.png
  
  上面是一般情况，正常来说引用都是存在环的，也就是说在求某个点的直接支配点时，它的有些父亲可能还没有找到自己的直接支配点，这时候子类当然也不能找到它自己的支配点，HAHA库中的做法是：如果某个父类没有支配点（也就是并未处理），就先跳过它，也就是认为少了一个父类，继续当前寻找直接支配点，等整棵树处理完毕以后，再迭代进行支配树的构建，直到所有的节点的支配树都找到且没有改变，至此结束。
  第一遍可能看的会有点蒙，我举个例子，比如下面的有向图：序号是已经排好的拓扑序
  
  图片.png
  
  

  我们现在求点3的直接支配点，具体步骤如下：

1. 找到所有指向3的引用点（也就是1和4），求他们的最近公共节点。
2. 1的支配点是它自己，但是4的直接支配点并未处理（第一遍还没轮到它呢），所以4的支配点肯定是null。
3. 这种情况下我们本次就先去掉父节点4，所以本次3的直接支配点是1。
4. 继续往后求4的直接支配点，即2和3的最近公共节点，也就是1。
5. 重头开始构建支配树，再次轮到3求直接支配点，因为4的直接支配点上一次已经求得是1，所以3最终的支配点就是1。
6. 在构造过程中所有节点的支配点未改变，结束支配树的构造。
   可以看到通过这种迭代的方式可以求得最终的构造树，但是缺点也显而易见，如果有向图过于复杂，时间复杂度会爆炸增长。其实构造支配树有一张更优的算法，Lengauer-Tarjan算法，不过我并没有去研究过，感兴趣的小伙伴可以去研究下。

3.4 Retained Size的计算

支配树构造完毕以后将每个对象的Shallow size加到各自的直接支配点上去就是某个对象的Retained Size大小。
上面就是HAHA库构造支配树和Reatined Size的整体流程。下面是代码实现：
//构建支配树并计算retainedSize

public void computeDominators() {
    if (mDominators == null) {
        //根据GC ROOT 计算拓扑序
        mTopSort = TopologicalSort.compute(getGCRoots());
        //根据拓扑序构建支配树
        mDominators = new Dominators(this, mTopSort);
        //根据支配树计算retained size
        mDominators.computeRetainedSizes();

        ShortestDistanceVisitor shortestDistanceVisitor = new ShortestDistanceVisitor();
        shortestDistanceVisitor.doVisit(getGCRoots());
    }
}

@NonNull
public static ImmutableList compute(@NonNull Iterable roots) {
    TopologicalSortVisitor visitor = new TopologicalSortVisitor();
    visitor.doVisit(roots);
    ImmutableList instances = visitor.getOrderedInstances();

    // We add the special sentinel node as the single root of the object graph, to ensure the
    // dominator algorithm terminates when having to choose between two GC roots.
    //设置一个超级源点
    Snapshot.SENTINEL_ROOT.setTopologicalOrder(0);

    // Set localIDs in the range 1..keys.size(). This simplifies the algorithm & data structures
    // for dominator computation.
    int currentIndex = 0;
     //设置拓扑序号，为后面查找最近公共祖先做铺垫
    for (Instance node : instances) {
        node.setTopologicalOrder(++currentIndex);
    }

    return instances;
}

@Override
public void doVisit(Iterable startNodes) {
    // root nodes are instances that share the same id as the node they point to.
    // This means that we cannot mark them as visited here or they would be marking
    // the actual root instance
    // TODO RootObj should not be Instance objects
    //将GC root压栈
    for (Instance node : startNodes) {
        node.accept(this);
    }
    //这里的算法是先根据右左根的方式放入队列
    while (!mStack.isEmpty()) {
        Instance node = mStack.peek();
        //这里会把各自的实例对象加入栈中
        //如果存在环，不会再进行入栈
        if (mSeen.add(node.getId())) {
            node.accept(this);
        } else {
            mStack.pop();
            //因为可能存在环，所以这里是防止重复写入
            if (mVisited.add(node.getId())) {
                mPostorder.add(node);
            }
        }
    }
}
//按照拓扑序反向去取出
ImmutableList getOrderedInstances() {
    return ImmutableList.copyOf(Lists.reverse(mPostorder));
}

/**
 * Kicks off the computation of dominators and retained sizes.
 */
public void computeRetainedSizes() {
    // Initialize retained sizes for all classes and objects, including unreachable ones.
    for (Heap heap : mSnapshot.getHeaps()) {
        for (Instance instance : Iterables.concat(heap.getClasses(), heap.getInstances())) {
            //先重置变成shallow size
            instance.resetRetainedSize();
        }
    }
    //设置对象的支配点
    computeDominators();
    // We only update the retained sizes of objects in the dominator tree (i.e. reachable).
    for (Instance node : mSnapshot.getReachableInstances()) {
        int heapIndex = mSnapshot.getHeapIndex(node.getHeap());
        // Add the size of the current node to the retained size of every dominator up to the
        // root, in the same heap.
        //计算某个对象的retained size就是从顶点开始到该对象的所有shallow size之和
        for (Instance dom = node.getImmediateDominator(); dom != Snapshot.SENTINEL_ROOT;
                dom = dom.getImmediateDominator()) {
            dom.addRetainedSize(heapIndex, node.getSize());
        }
    }
}

//图中可能会存在环，所以有可能在处理某个点时父节点还未被处理，也就是没有支配点。
//当前的算法是如果父类没有支配点就先跳过，等父类的支配点计算完以后再迭代去计算，
//直到所有计算完所有的支配点即可。
//缺陷：如果图很复杂，话费的时间就会非常庞大。
private void computeDominators() {
    // We need to iterate on the dominator computation because the graph may contain cycles.
    // TODO: Check how long it takes to converge, and whether we need to place an upper bound.
    boolean changed = true;
    //有可能会存在环，进行迭代计算
    while (changed) {
        changed = false;
        //把之前排好的拓扑序进行对象支配点的设置
        for (int i = 0; i < mTopSort.size(); i++) {
            Instance node = mTopSort.get(i);
            // Root nodes and nodes immediately dominated by the SENTINEL_ROOT are skipped.
            if (node.getImmediateDominator() != Snapshot.SENTINEL_ROOT) {
                Instance dominator = null;

                //如果有多个指向该对象的引用，就寻找最近支配点
                for (int j = 0; j < node.getHardReferences().size(); j++) {
                    //拿到指向它的引用
                    Instance predecessor = node.getHardReferences().get(j);
                    if (predecessor.getImmediateDominator() == null) {
                        // If we don't have a dominator/approximation for predecessor, skip it
                        continue;
                    }
                    if (dominator == null) {
                        dominator = predecessor;
                    } else {
                        Instance fingerA = dominator;
                        Instance fingerB = predecessor;
                        //找到最近公共祖先，也就是最近支配点
                        while (fingerA != fingerB) {
                            //这里有个疑问，如果存在环的情况下，有可能拿出的支配点是null
                            //会有空指针？
                            if (fingerA.getTopologicalOrder() < fingerB.getTopologicalOrder()) {
                                fingerB = fingerB.getImmediateDominator();
                            } else {
                                fingerA = fingerA.getImmediateDominator();
                            }
                        }
                        dominator = fingerA;
                    }
                }
                //设置该对象的支配点
                if (node.getImmediateDominator() != dominator) {
                    node.setImmediateDominator(dominator);
                    changed = true;
                }
            }
        }
    }
}

3.最短路径构建：

HAHA库对于引用链的构造也比较简单，从GC ROOT开始，利用PriorityQueue先进先出的性质，将构造一条从GC root开始不断加到实例变量上的引用链。下面是实现

@Override
public void doVisit(Iterable startNodes) {
    // root nodes are instances that share the same id as the node they point to.
    // This means that we cannot mark them as visited here or they would be marking
    // the actual root instance
    // TODO RootObj should not be Instance objects
    //将GC root放入队列中
    for (Instance node : startNodes) {
        node.accept(this);
    }
    
    while (!mPriorityQueue.isEmpty()) {
        Instance node = mPriorityQueue.poll();
        mVisitDistance = node.getDistanceToGcRoot() + 1;
        mPreviousInstance = node;
        node.accept(this);
    }
}

@Override
public void visitLater(Instance parent, @NonNull Instance child) {
    //如果当前child不在队列中
    //（是GC ROOT || 指向child的软引用列表不存在 || 指向chaild的软引用列表不包括当前的parent || child是一个软引用
    if (mVisitDistance < child.getDistanceToGcRoot() &&
            (parent == null ||
                 child.getSoftReferences() == null ||
                 !child.getSoftReferences().contains(parent) ||
                 child.getIsSoftReference())) {
        child.setDistanceToGcRoot(mVisitDistance);
        child.setNextInstanceToGcRoot(mPreviousInstance);
        mPriorityQueue.add(child);
    }
}