LeakCanary内存泄漏监听原理

大致流程：

  // Leakcanary的入口函数，
  public static RefWatcher install(Application application) {
    return refWatcher(application).listenerServiceClass(DisplayLeakService.class)
        .excludedRefs(AndroidExcludedRefs.createAppDefaults().build())
        .buildAndInstall();
  }

上述入口函数中主要做了这几件事：

• 创建AndroidRefWatcherBuilder对象，用于构建RefWatcher对象实例
• 设置内存分析结果的监听DisplayLeakService，该对象主要用于展示日志和显示泄漏信息的通知
• 设置不需要不需要考虑的引用
• 创建RefWatcher对象实例，

这里主要看一下buildAndInstall方法的实现，该方法主要作用是创建一个RefWatcher对象实例，然后开始观察目标对象引用（所谓的目标对象引用具体是指什么呢？）

  public RefWatcher buildAndInstall() {
    //创建RefWatcher实例
    RefWatcher refWatcher = build();
    if (refWatcher != DISABLED) {
     //设置用于展示内存泄漏信息的详情的页面可用
      LeakCanary.enableDisplayLeakActivity(context);
      //安装activity的引用监听，这里可以从命名猜测其观察的目标对象就是activity
      ActivityRefWatcher.install((Application) context, refWatcher);
    }
    return refWatcher;
  }

上述代码中我们主要关注Install方法，该方法主要是开始引用的监听，在看其具体实现之前，我们应该有如下的疑问：

• 观察的引用对象具体指什么
• 怎么判断对象泄漏了

  public static void install(Application application, RefWatcher refWatcher) {
    //创建ActivityRefWatcher对象并调用其watchActivities方法
    new ActivityRefWatcher(application, refWatcher).watchActivities();
  }
  public void watchActivities() {
    // 不要注册两次，因为registerActivityLifecycleCallbacks方法是直接向ArrayList中添加，并不去重
    stopWatchingActivities();
    //通过application注册一个activity的生命周期回调，但是也只能监听到activity的生命周期，说明这里观察的引用对象实际类型是activity
    application.registerActivityLifecycleCallbacks(lifecycleCallbacks);
  }

  public void stopWatchingActivities() {
    application.unregisterActivityLifecycleCallbacks(lifecycleCallbacks);
  }
  private final Application.ActivityLifecycleCallbacks lifecycleCallbacks =
      new Application.ActivityLifecycleCallbacks() {
         ...省略空实现
        @Override public void onActivityDestroyed(Activity activity) {
          //当activity销毁时调用onActivityDestroyed
          ActivityRefWatcher.this.onActivityDestroyed(activity);
        }
      };
  void onActivityDestroyed(Activity activity) {
    refWatcher.watch(activity);
  }     

上述install方法主要是观察activity的生命周期回调，当activity的onDestory方法回调时，说明其应该是无用对象，可以回收，接下来看一下其怎么判断activity是否已经被回收：

//watch方法有两个，其具体实现的方法是当前方法，前文调用的refWatcher.watch方法实际调用的是如下方法，其中referenceName为空长度为0的字符串“”
public void watch(Object watchedReference, String referenceName) {
    ...省略空检查和无效检查
    //记录开始时间
    final long watchStartNanoTime = System.nanoTime();
    //生成一个唯一的key
    String key = UUID.randomUUID().toString();
    //将key添加Set集合，如果该retainedKeys集合没有某个key了，则说明该key对应的reference对象被回收了
    retainedKeys.add(key);
    //创建了一个KeyedWeakReference对象，其是WeakReference类型的子类，
    final KeyedWeakReference reference =
        new KeyedWeakReference(watchedReference, key, referenceName, queue);//这里的queue是一个ReferenceQueue类型的对象
    //异步去确认引用是否被回收 
    ensureGoneAsync(watchStartNanoTime, reference);
  }

watch方法中需要注意的有两点：

• WeakReference + ReferenceQueue是怎么去监听到对象被回收
• 对象泄漏或者被回收时，需要做什么，在什么时机上做

关于对象的引用，我们知道在java中有四种，其区别如下：

• 强引用：平常申明的引用，比如 String a; 内存gc时，如果被外部引用，则不会回收
• 软引用：SoftReference类型，如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存
• 弱引用：WeakReference类型，只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存
• 虚引用：PhantomReference类型，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收

在LeakCanary中使用的弱引用的大致流程是，当WeakReference包含的对象未被回收时，ReferenceQueue队列中没有该对象，如果WeakReference包含的对象被回收后，则会将WeakReference添加到ReferenceQueue中，此时从ReferenceQueue队列中能获取到WeakReference对象。关于WeakReference + ReferenceQueue之间的关系，可以看一下这两篇文章：实践篇，原理篇
而ensureGoneAsync方法的流程如下：

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

ensureGoneAsync主要就是向AndroidWatchExecutor对象中添加了一个Retryable对象，我们先看AndroidWatchExecutor的怎么去执行的，之后在看这个ensureGone方法

  //AndroidWatchExecutor对象
  public void execute(Retryable retryable) {
    if (Looper.getMainLooper().getThread() == Thread.currentThread()) {
      //如果是主线程，则等待主线程空闲
      waitForIdle(retryable, 0);
    } else {
      //如果不是主线程，则切换到主线程，再调用waitForIdle
      postWaitForIdle(retryable, 0);
    }
  }
  //向主线程添加一个IdleHandler，该对象会在主线程空闲时被调用，详细的流程可以看下MessageQueue的next方法
  void waitForIdle(final Retryable retryable, final int failedAttempts) {
    // This needs to be called from the main thread.
    Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() {
      @Override public boolean queueIdle() {
        postToBackgroundWithDelay(retryable, failedAttempts);
        return false;//返回false表示该IdleHandler只会被执行一次
      }
    });
  }

AndroidWatchExecutor的execute方法主要是切换到主线程，等待主线程空闲时会调用IdleHandle的queueIdle方法，再调用postToBackgroundWithDelay方法

void postToBackgroundWithDelay(final Retryable retryable, final int failedAttempts) {
    long exponentialBackoffFactor = (long) Math.min(Math.pow(2, failedAttempts), maxBackoffFactor);
    long delayMillis = initialDelayMillis * exponentialBackoffFactor;
    //后台线程中执行Retryable对象的run方法，实际就是调用ensureGone方法
    backgroundHandler.postDelayed(new Runnable() {
      @Override public void run() {
        Retryable.Result result = retryable.run();//执行ensureGone
        //如果此时返回RETRY，表明需要再次尝试执行retryable.run();
        if (result == RETRY) {
          postWaitForIdle(retryable, failedAttempts + 1);
        }
      }
    }, delayMillis);
  }

下面就看下在后台线程中执行的ensureGone的实现：

Retryable.Result ensureGone(final KeyedWeakReference reference, final long watchStartNanoTime) {
    //尝试移出retainedKeys中的key值
    removeWeaklyReachableReferences();
   //判断引用是被回收，gone方法就是判断retainedKeys的key值是否存在
    if (gone(reference)) {
      return DONE;//返回DONE表明不需要再次尝试执行retryable.run();
    }
    //尝试通知jvm去执行gc
    gcTrigger.runGc();
    //再次尝试移出retainedKeys中的key值
    removeWeaklyReachableReferences();
    //再次判断引用是被回收
    if (!gone(reference)) {
      //表示该引用没有被回收
      if (heapDumpFile == RETRY_LATER) {
        // Could not dump the heap.
        return RETRY;//返回RETRY，表明需要再次尝试执行retryable.run();
      }
      ....省略内存堆分析的代码
    }
    return DONE;
  }
  
  private void removeWeaklyReachableReferences() {
    KeyedWeakReference ref;
    //如果ReferenceQueue队列中存在KeyedWeakReference对象，则会移出retainedKeys中的该对象的key，retainedKeys中的key实在RefWatch的watch方法中添加的
    while ((ref = (KeyedWeakReference) queue.poll()) != null) {
      retainedKeys.remove(ref.key);
    }
  }