LeakCanary 学习笔记

LeakCanary

在 Appliaction 中初始化 LeakCanary

if(!LeakCanary.isInAnalyzerProcess(this)){
    LeakCanary.install(this);
}

创建一个 RefWatcher 对象

public static RefWatcher install(Application application) {
  return refWatcher(application).listenerServiceClass(DisplayLeakService.class)
      .excludedRefs(AndroidExcludedRefs.createAppDefaults().build())
      .buildAndInstall();
}

监听 Activity 生命周期

public void watchActivities() {
  // Make sure you don't get installed twice.
  stopWatchingActivities();
  application.registerActivityLifecycleCallbacks(lifecycleCallbacks);
}

关注 Activity 的 onDestroy 生命周期

private final Application.ActivityLifecycleCallbacks lifecycleCallbacks =
    new Application.ActivityLifecycleCallbacks() {
      @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
      }
      @Override public void onActivityStarted(Activity activity) {
      }
      @Override public void onActivityResumed(Activity activity) {
      }
      @Override public void onActivityPaused(Activity activity) {
      }
      @Override public void onActivityStopped(Activity activity) {
      }
      @Override public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
      }
      @Override public void onActivityDestroyed(Activity activity) {
        ActivityRefWatcher.this.onActivityDestroyed(activity);
      }
    };

当 Activity 调用了 onDestroy() 方法后,RefWatcher 开始监听 Activity 对象

void onActivityDestroyed(Activity activity) {
  refWatcher.watch(activity);
}

第一步：使用 KeyedWeakReference 弱引用 Activity 对象，并且使用了 ReferenceQueue ，这里的 queue 表示，如果 activity 被 gc 回收了，那么 activity 就会被放入 queue 这个队列中。

给当前对象生成一个唯一的 key 标识：String key = UUID.randomUUID().toString();
将生成的 key 添加到 Set 集合中：retainedKeys.add(key);

这里的 retainedKeys 集合的作用：放入到这个集合中的每一个元素是一个个 Key ，每一个 key 表示一个引用对象，也就是说只要这个 retainedKeys 存在元素，那么对应元素表示的引用对象就还没有被回收。

第二步：在异步线程中去开始检测这个 activity 是否发生内存泄露了。

这里是在线程池中执行

public void watch(Object watchedReference, String referenceName) {
  if (this == DISABLED) {
    return;
  }
  checkNotNull(watchedReference, "watchedReference");
  checkNotNull(referenceName, "referenceName");
  final long watchStartNanoTime = System.nanoTime();
  String key = UUID.randomUUID().toString();
  retainedKeys.add(key);
  final KeyedWeakReference reference =
      new KeyedWeakReference(watchedReference, key, referenceName, queue);
  ensureGoneAsync(watchStartNanoTime, reference);
}

第一步：removeWeaklyReachableReferences();先检测一遍，queue 中引用是否出现在 retainedKeys 中，如果存在就要将这个引用对象对应的 key 从 retainedKeys 中移除

第二步：判断是否是在 debug 状态，如果是，则返回 RETRY ，那么这个任务将会重新被执行

第三步：在第一步检测之后，如果在这一步中，对象就已经被回收了，当前要检测的 activity 对象对应的 key 就从 retainedKeys 中移除了，那么 gone(reference) 方法一定会返回 true ，那么 ensureGone 返回 DONE ，表示不再监听这个对象，表示对象被移除了。如果第一步操作之后发现对象还是没有被回收，那么 gone(reference) 会返回 false

第四步：gcTrigger.runGc(); 执行 gc 操作，因为 activity 是在弱引用的，因此在 gc 时不管是否内存充足，弱引用的对象都会被回收。这里再次执行第一步中的removeWeaklyReachableReferences()操作再次地检测当前 activity 是否被回收。

第五步：执行第三步再次判断 activity 对象是否被回收了，如果被回收了，那么 ensureGone 返回 GONE 表示检测完毕，该对象没有发生内存泄露。如果检测到对象在 GC 之后，依旧没有被回收，那就要开始分析 activity 的引用链。

Retryable.Result ensureGone(final KeyedWeakReference reference, final long watchStartNanoTime) {
  long gcStartNanoTime = System.nanoTime();
  long watchDurationMs = NANOSECONDS.toMillis(gcStartNanoTime - watchStartNanoTime);
  removeWeaklyReachableReferences();
  if (debuggerControl.isDebuggerAttached()) {
    // The debugger can create false leaks.
    return RETRY;
  }
  if (gone(reference)) {
    return DONE;
  }
  gcTrigger.runGc();
  removeWeaklyReachableReferences();
  if (!gone(reference)) {
    long startDumpHeap = System.nanoTime();
    long gcDurationMs = NANOSECONDS.toMillis(startDumpHeap - gcStartNanoTime);
    File heapDumpFile = heapDumper.dumpHeap();
    if (heapDumpFile == RETRY_LATER) {
      // Could not dump the heap.
      return RETRY;
    }
    long heapDumpDurationMs = NANOSECONDS.toMillis(System.nanoTime() - startDumpHeap);
    heapdumpListener.analyze(
        new HeapDump(heapDumpFile, reference.key, reference.name, excludedRefs, watchDurationMs,
            gcDurationMs, heapDumpDurationMs));
  }
  return DONE;
}

当前 activity 在二次确定之后还是没有被回收，现在开始 dump 堆中内存数据并保存到一个文件中 heapDumpFile 保存。

File heapDumpFile = heapDumper.dumpHeap();

heapdumpListener.analyze 分析 dump 出来的数据。

@Override public void analyze(HeapDump heapDump) {
  checkNotNull(heapDump, "heapDump");
  HeapAnalyzerService.runAnalysis(context, heapDump, listenerServiceClass);
}

HeapAnalyzerService 是一个 IntentService ，之所以使用 IntentService ，它是一个 Service 组件，所以优先级比较高，不易被系统 kill，并且内部使用 HandlerThread 实现的异步线程去分析内存泄露。

@Override protected void onHandleIntent(Intent intent) {
  if (intent == null) {
    CanaryLog.d("HeapAnalyzerService received a null intent, ignoring.");
    return;
  }
  String listenerClassName = intent.getStringExtra(LISTENER_CLASS_EXTRA);
  HeapDump heapDump = (HeapDump) intent.getSerializableExtra(HEAPDUMP_EXTRA);
  HeapAnalyzer heapAnalyzer = new HeapAnalyzer(heapDump.excludedRefs);
  AnalysisResult result = heapAnalyzer.checkForLeak(heapDump.heapDumpFile, heapDump.referenceKey);
  AbstractAnalysisResultService.sendResultToListener(this, listenerClassName, heapDump, result);
}

checkForLeak 找到最短的 GCRoots 引用路径。

public AnalysisResult checkForLeak(File heapDumpFile, String referenceKey) {
  long analysisStartNanoTime = System.nanoTime();
  if (!heapDumpFile.exists()) {
    Exception exception = new IllegalArgumentException("File does not exist: " + heapDumpFile);
    return failure(exception, since(analysisStartNanoTime));
  }
  try {
    HprofBuffer buffer = new MemoryMappedFileBuffer(heapDumpFile);
    HprofParser parser = new HprofParser(buffer);
    Snapshot snapshot = parser.parse();
    deduplicateGcRoots(snapshot);
    Instance leakingRef = findLeakingReference(referenceKey, snapshot);
    // False alarm, weak reference was cleared in between key check and heap dump.
    if (leakingRef == null) {
      return noLeak(since(analysisStartNanoTime));
    }
    return findLeakTrace(analysisStartNanoTime, snapshot, leakingRef);
  } catch (Throwable e) {
    return failure(e, since(analysisStartNanoTime));
  }
}

分析完毕之后，将结果发送出来。

AbstractAnalysisResultService.sendResultToListener(this, listenerClassName, heapDump, result);

• onHeapAnalyzed 发送一个通知
• heapDump.heapDumpFile.delete(); 将 dump 文件删除

@Override protected final void onHandleIntent(Intent intent) {
  HeapDump heapDump = (HeapDump) intent.getSerializableExtra(HEAP_DUMP_EXTRA);
  AnalysisResult result = (AnalysisResult) intent.getSerializableExtra(RESULT_EXTRA);
  try {
    onHeapAnalyzed(heapDump, result);
  } finally {
    //noinspection ResultOfMethodCallIgnored
    heapDump.heapDumpFile.delete();
  }
}

可以覆写这个方法，在分析完毕之后，将对应的数据上传到后台服务器。

/**
 * You can override this method and do a blocking call to a server to upload the leak trace and
 * the heap dump. Don't forget to check {@link AnalysisResult#leakFound} and {@link
 * AnalysisResult#excludedLeak} first.
 */
protected void afterDefaultHandling(HeapDump heapDump, AnalysisResult result, String leakInfo) {
}```

记录于2021年5月30日