LeakCanary原理解析

相信很多人知道LeakCanay是square公司出的一个内存泄漏检测开源库，其使用也非常简单，在Application的onCreate中进行装载就可以，我们看下：

if (LeakCanary.isInAnalyzerProcess(this)) {
          //如果当前进程在内存泄漏检测进程中，则不需要再进行其他的初始化和LeakCanary的装载
            // This process is dedicated to LeakCanary for heap analysis.
            // You should not init your app in this process.
            return;
}
//装载LeakCanary
LeakCanary.install(this);

它的使用是非常简单，但是你了解怎么检查内存泄漏的？它是否可以检测所有的内存泄漏？
我们先看下LeakCanary.install的实现：

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

LeakCanary的install内部使用了链式编程方式一一对调用对应的函数，最后返回RefWatcher对象。其主要工作有：
一、创建RefWatcher对象的构造者
二、配置RefWatcher对象的构造者：设置内存泄漏检测结果处理Class；设置内存泄漏忽略的列表
三、构建RefWatcher，并装载内存泄漏检测器开始检测

一、创建RefWatcher对象的构造者

先看下install方法调用的第一个方法refWatcher方法要做什么：

public static AndroidRefWatcherBuilder refWatcher(Context context) {
    return new AndroidRefWatcherBuilder(context);
  }

它很简单，创建一个RefWatcher类的构造器，并返回此构造器。

二、配置RefWatcher对象的构造者

1、设置内存泄漏检测结果处理Class
install方法中创建AndroidRefWatcherBuilder之后，调用listenerServiceClass方法，设置内存泄漏检测结果处理Class：

public AndroidRefWatcherBuilder listenerServiceClass(
      Class listenerServiceClass) {
    return heapDumpListener(new ServiceHeapDumpListener(context, listenerServiceClass));
  }

public final T heapDumpListener(HeapDump.Listener heapDumpListener) {
    this.heapDumpListener = heapDumpListener;
    return self();
  }

listenerServiceClass先将内存检测结果处理Class包装成dump heap的监听者，再将其赋值给成员变量heapDumpListener，接着返回AndroidRefWatcherBuilder
2、设置内存泄漏忽略的列表
install中，设置完内存泄漏检测结果处理Class，调用excludedRefs设置内存泄漏忽略列表：

public final T excludedRefs(ExcludedRefs excludedRefs) {
    this.excludedRefs = excludedRefs;
    return self();
  }

忽略列表是怎么来的，在此不展开说，感兴趣的自己去看下其源码。

二、构建RefWatcher，并装载内存泄漏检测器开始检测

install方法最后调用buildAndInstall方法构建RefWathcer对象，并装载内存泄漏器进行内存监听。
这里有两个动作，一个是构建RefWatcher对象，二是装载内存泄漏器并进行内存监听：
1、构建RefWatch对象
我们看下buildAndInstall方法中构建RefWatcher的片段：

public RefWatcher buildAndInstall() {
    RefWatcher refWatcher = build();
    //...省略
}

调用build方法构建RefWatcher对象，我们看下build方法的实现：

public final RefWatcher build() {
    if (isDisabled()) {
      //不可以，返回Disable对象
      return RefWatcher.DISABLED;
    }
    //这是在install中设置的内存泄漏忽略列表对象
    ExcludedRefs excludedRefs = this.excludedRefs;
    if (excludedRefs == null) {
      excludedRefs = defaultExcludedRefs();
    }
    //在install方法中设置的内存泄漏监听者
    HeapDump.Listener heapDumpListener = this.heapDumpListener;
    if (heapDumpListener == null) {
      heapDumpListener = defaultHeapDumpListener();
    }
    
    DebuggerControl debuggerControl = this.debuggerControl;
    if (debuggerControl == null) {
      //设置过，所以才有默认的调试控制器
      debuggerControl = defaultDebuggerControl();
    }

    HeapDumper heapDumper = this.heapDumper;
    if (heapDumper == null) {
      //未设置过，设置为默认的堆抓取对象
      heapDumper = defaultHeapDumper();
    }

    WatchExecutor watchExecutor = this.watchExecutor;
    if (watchExecutor == null) {
      //未设置过，设置为默认的每次观察执行器
      watchExecutor = defaultWatchExecutor();
    }

    GcTrigger gcTrigger = this.gcTrigger;
    if (gcTrigger == null) {
      //未设置过，设置为默认的GC触发器
      gcTrigger = defaultGcTrigger();
    }
    //创建引用对象RefWatcher观察者，并返回
    return new RefWatcher(watchExecutor, debuggerControl, gcTrigger, heapDumper, heapDumpListener,
        excludedRefs);
  }

buildAndInstall首先是构建出引用对象观察者RefWatcher
2、装载内存泄漏器并进行内存监听
buildAndInstall创建引用对象观察者之后，使用此观察者装载内存泄漏检测器并监听引用对象：

public RefWatcher buildAndInstall() {
    //构建引用对象观察者
    RefWatcher refWatcher = build();
    if (refWatcher != DISABLED) {
      //如果允许检测内存泄漏
      //设置暂时内存泄漏分析结果
      LeakCanary.enableDisplayLeakActivity(context);
      //调用ActivityRefWatcher的install装载内存泄漏检测器
      ActivityRefWatcher.install((Application) context, refWatcher);
    }
    //返回引用对象观察者
    return refWatcher;
  }

buildAndInstall内部通过ActivityRefWatcher.install方法装载内存泄漏检测器，我们看下其实现：

public static void install(Application application, RefWatcher refWatcher) {
    new ActivityRefWatcher(application, refWatcher).watchActivities();
  }

它先创建一个ActivityRefWatcher对象，在调用ActivityRefWatcher对象的watchActivities方法，从命名上看我们可以大胆的猜测其观察的是Activity的引用对象。ok，我们继续看下watchActivities的实现：

public void watchActivities() {
    // Make sure you don't get installed twice.
    //注销之前设置的监听Activity生命周期
    stopWatchingActivities();
    //调用Android中application的registerActivityLifecycleCallbacks方法监听Activity的生命周期
    application.registerActivityLifecycleCallbacks(lifecycleCallbacks);
  }

  public void stopWatchingActivities() {
    //注销监听Activity生命周期
    application.unregisterActivityLifecycleCallbacks(lifecycleCallbacks);
  }

//监听Activity生命周期对象
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) {
          //Activity 销毁时回调onActivityDestroyed
          ActivityRefWatcher.this.onActivityDestroyed(activity);
        }
      };

watchActivities的核心是创建ActivityRefWatcher对象，并调用Application并注册监听Activity的生命周期。当Activity销毁时，会回调ActivityRefWatcher对象的onActivityDestroyed方法检测此Activity是否被回收内存。
ok，至此LeakCanary的install流程解析完，大家再回顾一下上面的流程，其实我们可以发现LeakCanary的内存泄漏检测是有局限性的，它只能检测与Activity相关的对象是否存在内存泄漏的可能，因为install的整体流程下来只有去监听Activity的生命周期，然后根据Activity销毁时去检测Activity和其相关的对象是否存在内存泄漏，其他组件类似Service、Brocast、ContentProvider等并没有看到有检测内存泄漏的逻辑。故LeakCanary只能检测Activity以及与Activity相关的对象是否存在内存泄漏，其他的它是无法检测的。

四、检测对象是否存在内存泄漏

上面的几个步骤分析了LeakCanary装载的流程，以及分析到Activity销毁时回调ActivityRefWatcher.this.onActivityDestroyed方法去检测分析Activity或者与Activity相关的对象是否存在内存泄漏。
Activity销毁时
我们看下Activity销毁时调用的onActivityDestroyed方法：

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

onActivityDestroyed方法中调用RefWatcher对象的watch方法：

public void watch(Object watchedReference) {
    watch(watchedReference, "");
  }

watch方法又调用其重载方法：

public void watch(Object watchedReference, String referenceName) {
    //...忽略
    //逻辑当前开始检测的时间
    final long watchStartNanoTime = System.nanoTime();
    //生成一个随机唯一id，作为与此引用对象（Activity）关联的标识
    String key = UUID.randomUUID().toString();
    //记录此key
    retainedKeys.add(key);
    //创建引用对象与id关联的弱引用对象
    final KeyedWeakReference reference =
        new KeyedWeakReference(watchedReference, key, referenceName, queue);
    //调用异步方法内存泄漏检测
    ensureGoneAsync(watchStartNanoTime, reference);
  }

watch方法又调用ensureGoneAsync方法进行异步检测分析。
在这里重点介绍下KeyedWeakReference：

final class KeyedWeakReference extends WeakReference