在对 hprof 文件进行处理前，首先需要对 hprof 文件格式有所了解。Android dump 的 hprof 文件和 java 的有一点点不一样，它在 java hprof 文件的基础上增加了几项，但文件格式是一样。所以需要先介绍下 java 的 hprof 文件格式，再介绍怎么处理 hprof 文件

hprof 文件格式

参考自 java openjdk8 hprof 文件格式

  在 java 中，hprof 文件有2部分组成，一部分是 hprof head，一部分是 hprof body。其中 head 比较简单，由版本号，IDSize和时间组成。

HPROF-HEAD.png

  body 的类型比较多，但是有规律，是由一系列的 Record 组成，由1个字节的Tag、4个字节的Time、4个字节的Length和Body组成，Tag表示该Record的类型，Body部分为该Record的内容，长度为Length。

HPROF-Record.png

以读取 STRING IN UTF8 为例
STRING IN UTF8 的结构如图：

HPROF-STRING.png

                final int tag = mStreamIn.read();
                final int timestamp = IOUtil.readBEInt(mStreamIn);
                final long length = IOUtil.readBEInt(mStreamIn) & 0x00000000FFFFFFFFL;
                switch (tag) {
                    case HprofConstants.RECORD_TAG_STRING:
                        acceptStringRecord(timestamp, length, hv);
                        break;



    private void acceptStringRecord(int timestamp, long length, HprofVisitor hv) throws IOException {
        final ID id = IOUtil.readID(mStreamIn, mIdSize);
        final String text = IOUtil.readString(mStreamIn, length - mIdSize);
        hv.visitStringRecord(id, text, timestamp, length);
    }

    public static String readString(InputStream in, long length) throws IOException {
        final byte[] buf = new byte[(int) length];
        readFully(in, buf, 0, length);
        return new String(buf, Charset.forName("UTF-8"));
    }

    public static void readFully(InputStream in, byte[] buf, int off, long length) throws IOException {
        int n = 0;
        while (n < length) {
            final int count = in.read(buf, n, (int) (length - n));
            if (count < 0) {
                throw new EOFException();
            }
            n += count;
        }
    }

  先读取1个字节 Tag、4个字节的 Time 和4个字节的 Length，之后再根据读取到的 tag 匹配相关的 Record,这里就是 tag == 0x01 来匹配的，匹配到是 STRING 之后再读取 length - ID 长度的内容为 value。到此 string 的解析完成。其余的也是相同的解析思路。

  在 body 中有比较重要的是 HEAP DUMP 和 HEAP DUMP SEGMENT，这二块在 body 中占的比重比较大。而且 Android 在这里新增了android 特有的模块。

//传统模块
public static final int HEAPDUMP_ROOT_UNKNOWN = 0xff;

public static final int HEAPDUMP_ROOT_JNI_GLOBAL = 0x1;
public static final int HEAPDUMP_ROOT_JNI_LOCAL = 0x2;
public static final int HEAPDUMP_ROOT_JAVA_FRAME = 0x3;
public static final int HEAPDUMP_ROOT_NATIVE_STACK = 0x4;
public static final int HEAPDUMP_ROOT_STICKY_CLASS = 0x5;
public static final int HEAPDUMP_ROOT_THREAD_BLOCK = 0x6;
public static final int HEAPDUMP_ROOT_MONITOR_USED = 0x7;
public static final int HEAPDUMP_ROOT_THREAD_OBJECT = 0x8;
public static final int HEAPDUMP_ROOT_CLASS_DUMP = 0x20;
public static final int HEAPDUMP_ROOT_INSTANCE_DUMP = 0x21;
public static final int HEAPDUMP_ROOT_OBJECT_ARRAY_DUMP = 0x22;
public static final int HEAPDUMP_ROOT_PRIMITIVE_ARRAY_DUMP = 0x23;
//android 特有
public static final int HEAPDUMP_ROOT_HEAP_DUMP_INFO = 0xfe;
public static final int HEAPDUMP_ROOT_INTERNED_STRING = 0x89;
public static final int HEAPDUMP_ROOT_FINALIZING = 0x8a;
public static final int HEAPDUMP_ROOT_DEBUGGER = 0x8b;
public static final int HEAPDUMP_ROOT_REFERENCE_CLEANUP = 0x8c;
public static final int HEAPDUMP_ROOT_VM_INTERNAL = 0x8d;
public static final int HEAPDUMP_ROOT_JNI_MONITOR = 0x8e;
public static final int HEAPDUMP_ROOT_UNREACHABLE = 0x90;  /* deprecated */
public static final int HEAPDUMP_ROOT_PRIMITIVE_ARRAY_NODATA_DUMP = 0xc3;

在网上及开发者网站上没有找到详细介绍，只能根据代码大概的写出来android特有的模块（基于 matrix 源码 com.tencent.matrix.resource.hproflib.HprofConstants，在art/runtime/hprof/hprof.cc 也有）

说明：value 中 name-size , name 是其名字（有可能没有），size 是其大小。

对于 body 中的 HEAP DUMP 和 HEAP DUMP SEGMENT 解析举个例子。

HPROF-ROOT_JNI_LOCAL.png

//1.先解析 record 的前三项，根据 tag == 0x0c || tag == 0x1c 来匹配 Record 的类型是 HEAP DUMP 或 HEAP DUMP SEGMENT
                final int tag = mStreamIn.read();
                final int timestamp = IOUtil.readBEInt(mStreamIn);
                final long length = IOUtil.readBEInt(mStreamIn) & 0x00000000FFFFFFFFL;
                switch (tag) {
                    case HprofConstants.RECORD_TAG_HEAP_DUMP:
                    case HprofConstants.RECORD_TAG_HEAP_DUMP_SEGMENT:
                        acceptHeapDumpRecord(tag, timestamp, length, hv);
                        break;
//2.再读出 1 个字节的子 tag == 0x02 来匹配 ROOT_JNI_LOCAL ，同时将上方的 length 减 1（ length == 0 时表示 HEAP DUMP 或 HEAP DUMP SEGMENT 类型的 Record 解析完成）
            final int heapDumpTag = mStreamIn.read();
            --length;
            switch (heapDumpTag) {
                case HprofConstants.HEAPDUMP_ROOT_JNI_LOCAL:
                    length -= acceptJniLocal(hdv);
                    break;
//3.接着读出一个 IDSize 和 二个 U4 。表示 ROOT_JNI_LOCAL 子类型解析完毕
    private int acceptJniLocal(HprofHeapDumpVisitor hdv) throws IOException {
        final ID id = IOUtil.readID(mStreamIn, mIdSize);
        final int threadSerialNumber = IOUtil.readBEInt(mStreamIn);
        final int stackFrameNumber = IOUtil.readBEInt(mStreamIn);
        hdv.visitHeapDumpJniLocal(id, threadSerialNumber, stackFrameNumber);
        return mIdSize + 4 + 4;
    }

处理 hprof 文件

处理 hprof 分为二类，，一是裁剪 hprof 文件，保留分析 OOM 的数据，使得在手机上的文件更容易的上传到后台分析。二是直接在手机上对 hprof 文件进行分析，中有用的信息。

1.裁剪 hprof 文件

  hprof 文件中绝大部分数据是 PRIMITIVE ARRAY DUMP，通常占据80%以上，而分析 OOM 只关系对象的大小和引用关系，并不关心内容，因此这部分是裁剪的突破口。

• Matrix
    Matrix 的 Hprof 文件裁剪功能的目标是将 Bitmap 和 String 以外的全部对象的基础类型数组的值移除，由于 Hprof 文件的分析功能只须要用到字符串数组和 Bitmap 的 buffer 数组。另外一方面，若是存在不一样的 Bitmap 对象其 buffer 数组值相同的状况，则能够将它们指向同一个 buffer，以进一步减少文件尺寸。
    主要流程为
    1.先寻找 bitmap、String、mBuffer、value 等类型的字符串索引。
    2.从字符串索引中找到相应的类索引。
    3.对于 bitmap 实例类会遍历其属性看是否有 mBuffer 与之匹配，如果有 2 次以上匹配的话就说明这个 bitmap 存在重复。对于 string 实例类会遍历其属性看是否有 value 与之匹配，匹配则记录到集合中。
    4.最后在 array 写入时判断其 ID 是否等于步骤3中重复的 bitmap ID ，等于则不写入。或者判断其 ID 是否等于步骤3中 string 记录的集合中的 ID，不在集合中则写入。

matrix 裁剪分析

• KOOM
    KOOM 的裁剪方式和 Martix 不同，他是在 dump hprof 文件的过程中对文件的 open 和 write 进行了 plt hook，判断其是否需要裁剪写入，主要裁剪的也是 array 中的基本数据类型数组，避免了打开 hprof 文件时 OOM。

源码在 KOOM 的 hprof_strip.cpp 中实现。
koom 裁剪分析

2.分析 hprof 文件

有 haha 库或 shark 库可以很方便的分析 hprof 文件。
haha 分析 hprof 文件代码

• 主要流程
  1.过滤重复的 GcRoot
  2.从快照中获取泄露的 act 实例，没有拿到就说明没有泄露
  3.广度遍历 GcRoot 的引用链，查看是否有与之匹配的 act 实例

// 开始分析的入口点在 HeapAnalyzerService
//HeapAnalyze
public @NonNull AnalysisResult checkForLeak(@NonNull File heapDumpFile,
    @NonNull String referenceKey,
    boolean computeRetainedSize) {
  long analysisStartNanoTime = System.nanoTime();
    ...
  try {
    listener.onProgressUpdate(READING_HEAP_DUMP_FILE);
    HprofBuffer buffer = new MemoryMappedFileBuffer(heapDumpFile);
    HprofParser parser = new HprofParser(buffer);
    listener.onProgressUpdate(PARSING_HEAP_DUMP);
    Snapshot snapshot = parser.parse();
    listener.onProgressUpdate(DEDUPLICATING_GC_ROOTS);
      // 过滤重复的 GcRoot
    deduplicateGcRoots(snapshot);
    listener.onProgressUpdate(FINDING_LEAKING_REF);
      // 拿到泄露 obj 在快照中的实例
    Instance leakingRef = findLeakingReference(referenceKey, snapshot);

    // False alarm, weak reference was cleared in between key check and heap dump.
    if (leakingRef == null) {
      String className = leakingRef.getClassObj().getClassName();
      return noLeak(className, since(analysisStartNanoTime));
    }
      // 广度遍历 GcRoot，查找泄露 leakingRef 与之遍历的 node 是否匹配
    return findLeakTrace(analysisStartNanoTime, snapshot, leakingRef, computeRetainedSize);
  } catch (Throwable e) {
    return failure(e, since(analysisStartNanoTime));
  }
}

    // 过滤重复的 GcRoot
  void deduplicateGcRoots(Snapshot snapshot) {
    // THashMap has a smaller memory footprint than HashMap.
    final THashMap<String, RootObj> uniqueRootMap = new THashMap<>();

    final Collection<RootObj> gcRoots = snapshot.getGCRoots();
    for (RootObj root : gcRoots) {
      String key = generateRootKey(root);
      if (!uniqueRootMap.containsKey(key)) {
        uniqueRootMap.put(key, root);
      }
    }

    // Repopulate snapshot with unique GC roots.
    gcRoots.clear();
    uniqueRootMap.forEach(new TObjectProcedure<String>() {
      @Override public boolean execute(String key) {
        return gcRoots.add(uniqueRootMap.get(key));
      }
    });
  }


  private Instance findLeakingReference(String key, Snapshot snapshot) {
      // KeyedWeakReference 包裹 activity 的类
    ClassObj refClass = snapshot.findClass(KeyedWeakReference.class.getName());
    if (refClass == null) {
      throw new IllegalStateException(
          "Could not find the " + KeyedWeakReference.class.getName() + " class in the heap dump.");
    }
    List<String> keysFound = new ArrayList<>();
    for (Instance instance : refClass.getInstancesList()) {
      List<ClassInstance.FieldValue> values = classInstanceValues(instance);
      Object keyFieldValue = fieldValue(values, "key");
      if (keyFieldValue == null) {
        keysFound.add(null);
        continue;
      }
      String keyCandidate = asString(keyFieldValue);
        // 找到泄露 act 
      if (keyCandidate.equals(key)) { 
        return fieldValue(values, "referent");
      }
      keysFound.add(keyCandidate);
    }
    throw new IllegalStateException(
        "Could not find weak reference with key " + key + " in " + keysFound);
  }


  private AnalysisResult findLeakTrace(long analysisStartNanoTime, Snapshot snapshot,
      Instance leakingRef, boolean computeRetainedSize) {

    listener.onProgressUpdate(FINDING_SHORTEST_PATH);
    ShortestPathFinder pathFinder = new ShortestPathFinder(excludedRefs);
      //广度遍历 GcRoot，查找泄露 leakingRef 与之遍历的 node 是否匹配
    ShortestPathFinder.Result result = pathFinder.findPath(snapshot, leakingRef);

      ...
      // 拿到泄露的路径
    LeakTrace leakTrace = buildLeakTrace(result.leakingNode);
      // 返回
    return leakDetected(result.excludingKnownLeaks, className, leakTrace, retainedSize,
        since(analysisStartNanoTime));
  }

  Result findPath(Snapshot snapshot, Instance leakingRef) {
    clearState();
    canIgnoreStrings = !isString(leakingRef);
    // GcRoot 入 toVisitQueue 队列，之后遍历
    enqueueGcRoots(snapshot);

    boolean excludingKnownLeaks = false;
    LeakNode leakingNode = null;
    while (!toVisitQueue.isEmpty() || !toVisitIfNoPathQueue.isEmpty()) {
      LeakNode node;
      if (!toVisitQueue.isEmpty()) {
          // 取出队列头
        node = toVisitQueue.poll();
      } else {...}

      // Termination
        // 找到了
      if (node.instance == leakingRef) {
        leakingNode = node;
        break;
      }

        // 将 node 的子节点入 toVisitQueue 队列，之后遍历
      if (node.instance instanceof RootObj) {
        visitRootObj(node);
      } else if (node.instance instanceof ClassObj) {
        visitClassObj(node);
      } else if (node.instance instanceof ClassInstance) {
        visitClassInstance(node);
      } else if (node.instance instanceof ArrayInstance) {
        visitArrayInstance(node);
      } else {
        throw new IllegalStateException("Unexpected type for " + node.instance);
      }
    }
    return new Result(leakingNode, excludingKnownLeaks);
  }

  private void enqueueGcRoots(Snapshot snapshot) {
      //遍历快照中所有的 GcRoot
    for (RootObj rootObj : HahaSpy.allGcRoots(snapshot)) {
      switch (rootObj.getRootType()) {
        case JAVA_LOCAL:
              ...
          break;
        case INTERNED_STRING:
        case DEBUGGER:
        case INVALID_TYPE:
          // An object that is unreachable from any other root, but not a root itself.
        case UNREACHABLE:
        case UNKNOWN:
          // An object that is in a queue, waiting for a finalizer to run.
        case FINALIZING:
          break;
        case SYSTEM_CLASS:
        case VM_INTERNAL:
          // A local variable in native code.
        case NATIVE_LOCAL:
          // A global variable in native code.
        case NATIVE_STATIC:
          // An object that was referenced from an active thread block.
        case THREAD_BLOCK:
          // Everything that called the wait() or notify() methods, or that is synchronized.
        case BUSY_MONITOR:
        case NATIVE_MONITOR:
        case REFERENCE_CLEANUP:
          // Input or output parameters in native code.
        case NATIVE_STACK:
        case JAVA_STATIC:
          enqueue(null, null, rootObj, null);
          break;
        default:
          throw new UnsupportedOperationException("Unknown root type:" + rootObj.getRootType());
      }
    }
  }

  private void enqueue(Exclusion exclusion, LeakNode parent, Instance child,
      LeakReference leakReference) {
    if (child == null) {
      return;
    }
      ...
    LeakNode childNode = new LeakNode(exclusion, child, parent, leakReference);
    if (visitNow) {
      toVisitSet.add(child);
      toVisitQueue.add(childNode);
    } else {
      toVisitIfNoPathSet.add(child);
      toVisitIfNoPathQueue.add(childNode);
    }
  }

// visitClassObj visitClassObj visitClassInstance visitArrayInstance 类似
  private void visitRootObj(LeakNode node) {
    RootObj rootObj = (RootObj) node.instance;
    Instance child = rootObj.getReferredInstance();

    if (rootObj.getRootType() == RootType.JAVA_LOCAL) {...} else {
      enqueue(null, node, child, null);
    }
  }