LeakCanary 原理分析

LeakCanary 原理分析

源码参考：square/leakcanary (GitHub)

一、整体结构

LeakCanary
├── 监听入口：ActivityLifecycleCallbacks、Fragment 等
├── RefWatcher      - 核心，WeakReference + ReferenceQueue 检测
├── KeyedWeakReference - 带 key 的弱引用
├── HeapDumper     - 生成 .hprof 内存快照
└── HeapAnalyzer   - 解析 hprof，构建泄漏路径

---

二、核心原理：WeakReference + ReferenceQueue

2.1 Java 引用与 ReferenceQueue

当对象只被 WeakReference 引用时，GC 会回收该对象。回收后，对应的 WeakReference 会被放入关联的 ReferenceQueue。

正常回收：
  对象 ──(仅被 WeakReference 引用)──→ GC 回收
                                          │
  WeakReference ──────────────────────────┘
          │
          └──→ 自动入队 ReferenceQueue

内存泄漏：
  对象 ──(被其他强引用持有)──→ GC 不回收
          │
  WeakReference ──→ 不入队，retainedKeys 仍包含其 key

2.2 KeyedWeakReference

// KeyedWeakReference.java
final class KeyedWeakReference extends WeakReference<Object> {
    public final String key;   // 随机 UUID，用于标识
    public final String name;  // 逻辑名，如 "Activity"

    KeyedWeakReference(Object referent, String key, String name,
                       ReferenceQueue<Object> referenceQueue) {
        super(referent, referenceQueue);  // 关联引用队列
        this.key = key;
        this.name = name;
    }
}

• referent：被监控对象（如 Activity）
• key：UUID，存入 retainedKeys，用于判断是否已回收
• referenceQueue：对象被 GC 后，该 Reference 会入队

---

三、RefWatcher：核心检测逻辑

3.1 watch()：开始监控

// RefWatcher.java
public void watch(Object watchedReference, String referenceName) {
    if (this == DISABLED) return;

    String key = UUID.randomUUID().toString();
    retainedKeys.add(key);  // 1. 将 key 加入强引用 Set

    final KeyedWeakReference reference =
        new KeyedWeakReference(watchedReference, key, referenceName, queue);
    // 2. 创建弱引用，关联 queue

    ensureGoneAsync(watchStartNanoTime, reference);
    // 3. 异步执行检测
}

private void ensureGoneAsync(final long watchStartNanoTime, final KeyedWeakReference reference) {
    watchExecutor.execute(new Retryable() {
        @Override public Retryable.Result run() {
            return ensureGone(reference, watchStartNanoTime);
        }
    });
}

步骤	逻辑	说明
1	retainedKeys.add(key)	用强引用 Set 持有 key，与 WeakReference 分离
2	new KeyedWeakReference(..., queue)	弱引用指向对象，并关联 ReferenceQueue
3	ensureGoneAsync()	延迟后（如 5s）在子线程执行 ensureGone()

3.2 removeWeaklyReachableReferences()：清理已回收的 key

// 当对象被 GC 回收时，其 WeakReference 会入队
private void removeWeaklyReachableReferences() {
    KeyedWeakReference ref;
    while ((ref = (KeyedWeakReference) queue.poll()) != null) {
        retainedKeys.remove(ref.key);  // 从 Set 中移除，表示已回收
    }
}

3.3 gone()：判断是否已回收

private boolean gone(KeyedWeakReference reference) {
    return !retainedKeys.contains(reference.key);
}

• 对象被 GC → WeakReference 入队 → removeWeaklyReachableReferences() 移除 key → gone() 为 true
• 对象未被 GC（泄漏）→ WeakReference 不入队 → key 仍在 retainedKeys → gone() 为 false

3.4 ensureGone()：完整检测流程

Retryable.Result ensureGone(final KeyedWeakReference reference, final long watchStartNanoTime) {
    removeWeaklyReachableReferences();
    // 1. 先清理已入队的引用

    if (debuggerControl.isDebuggerAttached()) {
        return RETRY;  // 调试器可能造成误报
    }
    if (gone(reference)) {
        return DONE;   // 2. 已回收，结束
    }

    gcTrigger.runGc();
    // 3. 主动触发 GC
    removeWeaklyReachableReferences();

    if (!gone(reference)) {
        // 4. 仍未回收，判定泄漏
        File heapDumpFile = heapDumper.dumpHeap();
        heapdumpListener.analyze(
            new HeapDump(heapDumpFile, reference.key, reference.name, ...));
    }
    return DONE;
}

步骤	逻辑	说明
1	removeWeaklyReachableReferences()	处理已入队的 Reference，移除对应 key
2	gone(reference)	若 key 已移除，说明已回收，直接返回
3	gcTrigger.runGc()	主动触发 GC
4	再次 removeWeaklyReachableReferences() + gone()	若仍存在，判定泄漏，执行 heap dump

---

四、监听入口：Activity 销毁时 watch

// ActivityRefWatcher（或类似实现）
// 通过 Application.registerActivityLifecycleCallbacks 注册
@Override
public void onActivityDestroyed(Activity activity) {
    refWatcher.watch(activity, activity.getClass().getName());
}

• onActivityDestroyed() 在 Activity 销毁时调用
• 此时将 Activity 传给 RefWatcher.watch()，开始监控
• Fragment、Service、ViewModel 等同理，在对应销毁时机调用 watch()

---

五、检测流程总览

Activity.onDestroy()
    │
    └── refWatcher.watch(activity)
            │
            ├── retainedKeys.add(key)
            ├── new KeyedWeakReference(activity, key, name, queue)
            └── ensureGoneAsync()
                    │
                    └── 延迟 5s 后，子线程执行 ensureGone()
                            │
                            ├── removeWeaklyReachableReferences()
                            │       └── queue.poll()，已回收的 Reference 入队，移除对应 key
                            │
                            ├── gone(reference) ?
                            │       ├── true  ──→ 结束
                            │       └── false ──→ 继续
                            │
                            ├── gcTrigger.runGc()
                            ├── removeWeaklyReachableReferences()
                            ├── gone(reference) ?
                            │       ├── true  ──→ 结束
                            │       └── false ──→ 判定泄漏
                            │
                            └── heapDumper.dumpHeap()
                                    └── heapdumpListener.analyze()
                                            └── 解析 hprof，构建 GC Root → 泄漏对象路径

---

六、Heap Dump 与泄漏路径分析

阶段	职责
HeapDumper	调用 Debug.dumpHprofData() 生成 .hprof 文件
HeapAnalyzer	解析 hprof，找到 KeyedWeakReference 的 referent（泄漏对象）
路径构建	从泄漏对象反向追溯到 GC Root，得到引用链
展示	通知栏展示泄漏路径，便于定位

---

七、关键点小结

机制	作用
WeakReference	不阻止 GC，对象可被回收
ReferenceQueue	对象被回收后，Reference 入队，用于判断
retainedKeys	强引用 Set 存 key，与 Reference 分离，避免误判
延迟检测	给 GC 时间，避免误报
主动 GC	确保已触发回收再判断
Heap Dump	泄漏确认后，生成快照分析引用链