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日
