关于android:LeakCanary-分析

LeakCanary是Square公司推出个一个内存泄露检测工具，

[地址：[https://square.github.io/leak…]()](https://square.github.io/leak…

应用

简略应用，

在我的项目Model的build.gradle文件中dependencies{}中退出

debugImplementation 'com.squareup.leakcanary:leakcanary-android:version'

而后在你的App中的onCreate()办法中增加

LeakCanary.install(this);

这样LeakCanary就能够监控零碎的Activity的内存泄露了，默认应用只能检测到Activity的内存泄露。

如果你想检测其余对象的内存泄露，能够自定义监控对象。

    refWatcher = LeakCanary.install(this);

LeakCanary.install(this) 办法返回一个RefWatcher对象，调用该队的的watch()办法就行了。

该办法的签名如下

//传入你想检测的对象
public void watch(Object watchedReference) {
 watch(watchedReference, "");
}

​

原理

LeakCanary 中对内存透露检测的外围原理就是基于 WeakReference 和 ReferenceQueue 实现的。

1.  当一个 Activity 须要被回收时，就将其包装到一个 WeakReference 中，并且在 WeakReference 的结构器中传入自定义的 ReferenceQueue。

2.  而后给包装后的 WeakReference 做一个标记 Key，并且在一个强援用 Set 中增加相应的 Key 记录

3.  最初被动触发 GC，遍历自定义 ReferenceQueue 中所有的记录，并依据获取的 Reference 对象将 Set 中的记录也删除

通过下面 3 步之后，还保留在 Set 中的就是：该当被 GC 回收，然而理论还保留在内存中的对象，也就是产生透露了的对象

public static RefWatcher install(Application application) {
 return install(application, DisplayLeakService.class);
}
​
 public static RefWatcher install(Application application,
 Class<? extends AbstractAnalysisResultService> listenerServiceClass) {
 if (isInAnalyzerProcess(application)) {
 return RefWatcher.DISABLED;
 }
 enableDisplayLeakActivity(application);
 HeapDump.Listener heapDumpListener =
 new ServiceHeapDumpListener(application, listenerServiceClass);
 RefWatcher refWatcher = androidWatcher(application, heapDumpListener);
 //  LeakCanary 中监听 Activity 生命周期是由 ActivityRefWatch 来负责的，次要是通过注册 Android 零碎提供的 ActivityLifecycleCallbacks，来监听 Activity 的生命周期办法的调用，
 ActivityRefWatcher.installOnIcsPlus(application, refWatcher);//默认只检测Activity的内存泄露
 return refWatcher;//返回refWatcher对象，
 }

RefWatcher对象的构造方法如下。

     private final Executor watchExecutor; //线程池
     private final DebuggerControl debuggerControl;
     private final GcTrigger gcTrigger;//GC触发器
     private final HeapDumper heapDumper;
     private final Set<String> retainedKeys; //检测对象的Key汇合
     private final ReferenceQueue<Object> queue;//若援用队列
     private final HeapDump.Listener heapdumpListener;

    public RefWatcher(Executor watchExecutor, DebuggerControl debuggerControl, GcTrigger gcTrigger,HeapDumper heapDumper, HeapDump.Listener heapdumpListener) {
     this.watchExecutor = checkNotNull(watchExecutor, "watchExecutor");
     this.debuggerControl = checkNotNull(debuggerControl, "debuggerControl");
     this.gcTrigger = checkNotNull(gcTrigger, "gcTrigger");
     this.heapDumper = checkNotNull(heapDumper, "heapDumper");
     this.heapdumpListener = checkNotNull(heapdumpListener, "heapdumpListener");
     retainedKeys = new CopyOnWriteArraySet<>();
     queue = new ReferenceQueue<>();
    }

咱们看下ActivityRefWatcher这个类的外部实现，该类只反对ICE_CREAM_SANDWICH以上的版本。

@TargetApi(ICE_CREAM_SANDWICH) public final class ActivityRefWatcher {
​
​
 private final Application application;
 private final RefWatcher refWatcher;

 public static void installOnIcsPlus(Application application, RefWatcher refWatcher) {
 低于ICE_CREAM_SANDWICH版本的本人在BaseActivity的onDestroy办法中解决
 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();
 }
​
 /**
 * 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");
 }
​
​
 public void watchActivities() {
 // Make sure you don't get installed twice.
 stopWatchingActivities();
//   application注册ActivityLifecycleCallbacks接口
 application.registerActivityLifecycleCallbacks(lifecycleCallbacks);
 }
​
 public void stopWatchingActivities() {
 application.unregisterActivityLifecycleCallbacks(lifecycleCallbacks);
 }

 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) {
 }
​
 //在Activity销毁时开启检测
 @Override public void onActivityDestroyed(Activity activity) {
 ActivityRefWatcher.this.onActivityDestroyed(activity);
 }
 };

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

}

最初调用refWatcher对象的watch办法。最初回调它的重载办法。

public void watch(Object watchedReference) {
 watch(watchedReference, "");
}
​
 public void watch(Object watchedReference, String referenceName) {
 //对检测对象和援用名称判空
 checkNotNull(watchedReference, "watchedReference");
 checkNotNull(referenceName, "referenceName");
 if (debuggerControl.isDebuggerAttached()) {
 return;
 }
 //检测开始工夫
 final long watchStartNanoTime = System.nanoTime();
 //随机生成Key
 String key = UUID.randomUUID().toString();
 //将Key放入retainedKeys汇合中，retainedKeys是一个CopyOnWriteArraySet对象。
 retainedKeys.add(key);
 //将检测对象，key,referenceName，queue 构建一个KeyedWeakReference对象
 final KeyedWeakReference reference =
 new KeyedWeakReference(watchedReference, key, referenceName, queue);
​
 //向线程池watchExecutor提交一个工作。在该工作里启动检测。
 watchExecutor.execute(new Runnable() {
 @Override public void run() {
 ensureGone(reference, watchStartNanoTime);
 }
 });
 }


 void ensureGone(KeyedWeakReference reference, long watchStartNanoTime) {
 long gcStartNanoTime = System.nanoTime();
​
 long watchDurationMs = NANOSECONDS.toMillis(gcStartNanoTime - watchStartNanoTime);
 //移出援用队列里的对象
 removeWeaklyReachableReferences();
 if (gone(reference) || debuggerControl.isDebuggerAttached()) {
 return;
 }
 //启动垃圾回收
 gcTrigger.runGc();
 //移出援用队列里的对象
 removeWeaklyReachableReferences();
 //如果retainedKeys里边仍然蕴含改若援用对象的key.阐明该弱对象援用的对象泄露了。
 if (!gone(reference)) {
 long startDumpHeap = System.nanoTime();
 long gcDurationMs = NANOSECONDS.toMillis(startDumpHeap - gcStartNanoTime);
 //生成Dump文件
 File heapDumpFile = heapDumper.dumpHeap();
​
 if (heapDumpFile == null) {
 // Could not dump the heap, abort.
 return;
 }
 long heapDumpDurationMs = NANOSECONDS.toMillis(System.nanoTime() - startDumpHeap);
 heapdumpListener.analyze(
 new HeapDump(heapDumpFile, reference.key, reference.name, watchDurationMs, gcDurationMs,
 heapDumpDurationMs));
 }
 }

 //移出如援用对象
 private void removeWeaklyReachableReferences() {
 // WeakReferences are enqueued as soon as the object to which they point to becomes weakly
 // reachable. This is before finalization or garbage collection has actually happened.
 //垃圾回收启动之前，一旦弱援用对象援用的对象变得弱援用时，弱援用对象就会退出到它外部的队列里。
 KeyedWeakReference ref;
 //遍历队列，如果队列里的元素等于以后的对象，阐明以后对象被回收了，就从retainedKeys里移出弱援用对象对一个的key.
 while ((ref = (KeyedWeakReference) queue.poll()) != null) {
 retainedKeys.remove(ref.key);
 }
 }

 //判断以后的reference对象对象的Key是否蕴含在retainedKeys，如果在就阐明reference没有被垃圾回收
 private boolean gone(KeyedWeakReference reference) {
 return !retainedKeys.contains(reference.key);
 }