LeakCanary源码阅读

一、相关概念

1. 弱引用与引用队列

在WeakReference指向的对象在GC时被回收后，WeakReference本身其实也就没有用了，系统会把该弱引用对象加入到与之关联的ReferenceQueue中（当然前提是你创建该WeakReference的时候给其关联了ReferenceQueue）。

---

摘自 零度anngle 的CSDN 博客 ，全文地址请点击：https://blog.csdn.net/zmx729618/article/details/54093532?utm_source=copy

二、使用

1. gradle中添加依赖

dependencies {
  debugImplementation 'com.squareup.leakcanary:leakcanary-android:1.6.1'
  releaseImplementation 'com.squareup.leakcanary:leakcanary-android-no-op:1.6.1'
  // Optional, if you use support library fragments:
  debugImplementation 'com.squareup.leakcanary:leakcanary-support-fragment:1.6.1'
}

leakcanary-android-no-op是用于release版本的，因为LeakCanary会不断GC，造成stop the world 这在release版本中时不允许的，因此内存泄漏检测我们只能用在debug版本。

2. 在Application中进行初始化操作

public class ExampleApplication extends Application {

  @Override public void onCreate() {
    super.onCreate();
    if (LeakCanary.isInAnalyzerProcess(this)) {
      // This process is dedicated to LeakCanary for heap analysis.
      // You should not init your app in this process.
      return;
    }
    LeakCanary.install(this);
    // Normal app init code...
  }
}

LeakCanary在主进程中检测内存泄漏，在另外的进程中分析hprof文件。多进程下Application被多次创建，为了防止在 Application中出现无用的重复初始化，在Application中可通过processName来过滤，只有在指定进程才做相应的初始化。

3. 在Manifest中配置Application

....

三、源码分析

3.1LeakCanary的准备工作

LeakCanary检测内存泄漏的入口：Application中的

LeakCanary.install(this);

该方法的主要作用是通过Builder模式构建RefWatcher实例，并做一些初始化的准备工作（为application注册ActivityLifecycleCallback）

public final class LeakCanary{
    public static RefWatcher install(Application application){
        // 采用构造器模式构造RefWatcher实例，链式调用
            return ((AndroidRefWatcherBuilder)refWatcher(application)
            .listenerServiceClass(DisplayLeakService.class)
            .excludedRefs(AndroidExcludedRefs.createAppDefaults().build()))
            .buildAndInstall();
    }
public static AndroidRefWatcherBuilder refWatcher(Context context) {
        return new AndroidRefWatcherBuilder(context);
    }
}

1)得到AndroidRefWatcherBuilder

上述方法采用构建者模式，（AndroidRefWatcherBuilder extends RefWatcherBuilder）最终构造出一个RefWatcher实例，RefWatcher用来监视一个引用的可达情况

2).listenerServiceClass(DisplayLeakService.class)

public final class AndroidRefWatcherBuilder{
    
    public AndroidRefWatcherBuilder listenerServiceClass(Class listenerServiceClass) {
        return (AndroidRefWatcherBuilder)this.heapDumpListener(new ServiceHeapDumpListener(this.context, listenerServiceClass));
    }
}

上述AbstractAnalysisResultService是一个抽象类，继承自IntentService（public abstract class AbstractAnalysisResultService extends IntentService），用于处理heapDump结果。
LeakCanary#install()中传入的参数DiaplayLeakService继承自AbstractAnalysisResultService（public class DisplayLeakService extends AbstractAnalysisResultService），运行在独立的进程中

3)excludedRefs(...)

有时候我们需要忽略一些特殊情况下的内存泄漏比如SDK或者制造商导致的内存泄漏，这些内存泄漏我们并不需要显示出来，那么刚好AndroidExcludedRefs这个枚举就派上用场了。

4)buildAndInstall()

public final class AndroidRefWatcherBuilder{

    public RefWatcher buildAndInstall() {
        RefWatcher refWatcher = this.build();
        if(refWatcher != RefWatcher.DISABLED) {
            LeakCanary.enableDisplayLeakActivity(this.context);
            // 调用ActivityRefWatcher.install()方法，将Application的上下文和RefWatcher传入
            ActivityRefWatcher.install((Application)this.context, refWatcher);
        }
        return refWatcher;
    }
}

构建出RefWatcher实例，紧接着调用ActivityRefWatcher.install((Application)this.context, refWatcher);，这是重点

public final class ActivityRefWatcher{
    // ActivityLifecycleCallbacks：应用内Activity生命周期发生变化时会回调相应函数【该方法在API14后才有】
    private final ActivityLifecycleCallbacks lifecycleCallbacks = new ActivityLifecycleCallbacks() {
        public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        }

        public void onActivityStarted(Activity activity) {
        }

        public void onActivityResumed(Activity activity) {
        }

        public void onActivityPaused(Activity activity) {
        }

        public void onActivityStopped(Activity activity) {
        }

        public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
        }

        public void onActivityDestroyed(Activity activity) {
            ActivityRefWatcher.this.onActivityDestroyed(activity);
        }
    };
    void onActivityDestroyed(Activity activity) {
        this.refWatcher.watch(activity);
    }
    // install
    public static void install(Application application, RefWatcher refWatcher) {
        (new ActivityRefWatcher(application, refWatcher)).watchActivities();
    }
    // 构造函数
    public ActivityRefWatcher(Application application, RefWatcher refWatcher) {
        this.application = (Application)Preconditions.checkNotNull(application, "application");
        this.refWatcher = (RefWatcher)Preconditions.checkNotNull(refWatcher, "refWatcher");
    }
    public void watchActivities() {
        this.stopWatchingActivities();
        // 为application注册ActivityLiftcycleCallbacks，监听应用内所有Activity的生命周期
        this.application.registerActivityLifecycleCallbacks(this.lifecycleCallbacks);
    }

    public void stopWatchingActivities() {
        // 为application取消注册ActivityLiftcycleCallbacks监听
        this.application.unregisterActivityLifecycleCallbacks(this.lifecycleCallbacks);
    }
}

上面的代码逻辑其实很简单，就是为application注册ActivityLifecycleCallback，监听应用内所有Activity的生命周期，LeakCanary只关注onDestroy()，在Activity的onDestroy()回调时去做一些事情。

3.2 LeakCanary检测是否发生了内存泄漏

当Activity回调了生命周期中的onDestory()时，LeakCanary就运行下面的代码检测是否发生内存泄漏

public final class  RefWatcher{
    
    private final Set retainedKeys;
    // 引用队列
    private final ReferenceQueue