leakcanary1.5源码分析

介绍

内存泄漏检测工具，square公司出品，github地址https://github.com/square/leakcanary。
gradle引用：

debugCompile 'com.squareup.leakcanary:leakcanary-android:1.5'
releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.5'

使用

在自定义application中onCreat方法中调用下面代码。默认只是检测所有activity中的内存泄漏。如果想检测fragment、service等的内存泄漏，需要在相应的类的onDestory方法中调用refWatcher.watch(this)即可。然后在使用app的过程中，如果出现内存泄漏就会在leaks的app中listview展示出来，并且有相应的路径。

     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); 

问题

使用特别简单，但是想了想，有几个问题值得思考。
如何检测到所有activity的内存泄漏的？
内存泄漏检测机制是什么？
内存泄漏轨迹的生成过程 ？

源码分析

    public static RefWatcher install(Application application) {
    return refWatcher(application)//创建引用监听者
        .listenerServiceClass(DisplayLeakService.class)//显示泄漏信息service
        .excludedRefs(AndroidExcludedRefs.createAppDefaults().build())
        .buildAndInstall();
    }

以上为install源码，不难发现buildAndInstall是一个build模式，一般build都是一些校验或者初始化。

    public RefWatcher buildAndInstall() {
    RefWatcher refWatcher = build();
    if (refWatcher != DISABLED) {
      LeakCanary.enableDisplayLeakActivity(context);
      ActivityRefWatcher.installOnIcsPlus((Application) context, refWatcher);
    }
    return refWatcher;
    }

然后build之后创建一个RefWatcher对象。

    public final RefWatcher build() {
    if (isDisabled()) {
      return RefWatcher.DISABLED;
    }


    ExcludedRefs excludedRefs = this.excludedRefs;
    if (excludedRefs == null) {
      excludedRefs = defaultExcludedRefs();
    }

    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) {
      gcTrigger = defaultGcTrigger();
    }

    return new RefWatcher(watchExecutor, debuggerControl, gcTrigger, heapDumper, heapDumpListener,
        excludedRefs);
    }

创建完对象之后，enableDisplayLeakActivity方法是否展示泄漏activity，最重要的是ActivityRefWatcher.installOnIcsPlus((Application) context, refWatcher)处理。

    @TargetApi(ICE_CREAM_SANDWICH) public final class ActivityRefWatcher {

    public static void installOnIcsPlus(Application application, RefWatcher refWatcher) {
    if (SDK_INT < ICE_CREAM_SANDWICH) {
      // If you need to support Android < ICS, override onDestroy() in your base activity.
      return;
    }
    ActivityRefWatcher activityRefWatcher = new ActivityRefWatcher(application, refWatcher);
    activityRefWatcher.watchActivities();
    }

    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);
        }
      };

    private final Application application;
    private final RefWatcher refWatcher;

    /**
     * Constructs an {@link ActivityRefWatcher} that will make sure the activities     are not leaking
       * after they have been destroyed.
     */
    public ActivityRefWatcher(Application application, final RefWatcher refWatcher) {
    this.application = checkNotNull(application, "application");
    this.refWatcher = checkNotNull(refWatcher, "refWatcher");
    }

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

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

    public void stopWatchingActivities() {
    application.unregisterActivityLifecycleCallbacks(lifecycleCallbacks);
    }
    }

installOnIcsPlus方法先判断版本<14 不能使用，然后调用创建ActivityRefWatcher对象，调用watchActivities方法，watchActivities里面就是将传入的application注册registerActivityLifecycleCallbacks用来获取这个application的所有activity的生命周期。然后在Application.ActivityLifecycleCallbacks回调中onActivityDestroyed生命周期里面调用ActivityRefWatcher.this.onActivityDestroyed(activity)方法，最后调用到refWatcher.watch(activity)，接下来进入watch来看下。

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

     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);
    }

首先根据uuid创建一个key放入retainedKeys数组里面，添加弱引用的标识，KeyedWeakReference是继承WeakReference的类，一个弱引用的封装。看到
new KeyedWeakReference(watchedReference, key, referenceName, queue)，是在创建一个弱引用，并放到ReferenceQueue引用队列中。KeyedWeakReference里面日常参数校验，以及调用WeakReference的super方法。

    final class KeyedWeakReference extends WeakReference