LeakCanary 原理和用法简单总结

LeakCanary是Square公司基于MAT开发的一款监控Android内存泄漏的开源框架。

Java基础知识

在总结之前需要先了解一些Java的基础知识。

1. 强引用

通常可以认为是通过new出来的对象，即使内存不足，GC进行垃圾收集的时候也不会主动回收。
Object obj = new Object();
2. 软引用

在内存不足的时候，GC进行垃圾收集的时候会被GC回收。
Object obj = new Object(); SoftReference<Object> softReference = new
SoftReference<>(obj);
3. 弱引用

无论内存是否充足，GC进行垃圾收集的时候都会回收。
Object obj = new Object(); WeakReference<Object> weakReference = new
WeakReference<>(obj);
4. 虚引用

和弱引用类似，主要区别在于虚引用必须和引用队列一起使用。
Object obj = new Object(); ReferenceQueue<Object> referenceQueue = new
ReferenceQueue<>(); PhantomReference<Object> phantomReference = new
PhantomReference<>(obj, referenceQueue);
5. 引用队列

如果软引用和弱引用被GC回收，JVM就会把这个引用加到引用队列里，如果是虚引用，在回收前就会被加到引用队列里。

6. GC回收机制算法 - 可达性算法

可达性算法是目前Java虚拟机比较常用的GC回收机制算法。

主要原理是是通过GCRoots对象作为根节点，从根节点开始往下遍历，遍历的路径称为引用链，当一个对象到GC
Roots没有任何引用链相连的时候，则说明此对象是不可用的。

LeakCanary 集成和使用

首先需要配置build.gradle
debugImplementation 'com.squareup.leakcanary:leakcanary-android:1.5.4'
releaseImplementation 'com.squareup.leakcanary:leakcanary-android-no-op:1.5.4'
然后在Application类中加入以下代码。
public class DevApp extends Application { @Override public void onCreate() {
if (!LeakCanary.isInAnalyzerProcess(this)) { LeakCanary.install(this); }
super.onCreate(); } }

LeakCanary默认监控Activity类，如果我们需要自定义监控对象，那么就需要在我们确定不需要某个对象之后，手动调用RefWatcher对象的watch方法进行监控。
public class DevApp extends Application { @Override public void onCreate() {
LeakCanaryWatcher.initialize(this); super.onCreate(); } } public class
LeakCanaryWatcher { private static RefWatcher sRefWatcher; private
LeakCanaryWatcher() { throw new IllegalStateException("Utility class"); }
public static void initialize(Application application) { if
(!LeakCanary.isInAnalyzerProcess(application)) { sRefWatcher =
LeakCanary.install(application); } } public static void watch(Object obj) { if
(sRefWatcher != null) { sRefWatcher.watch(obj); } } }
LeakCanary原理

首先从install方法入手，分析LeakCanary是如何监控内存泄漏的。
public static RefWatcher install(Application application) { return
refWatcher(application) .listenerServiceClass(DisplayLeakService.class)
.excludedRefs(AndroidExcludedRefs.createAppDefaults().build())
.buildAndInstall(); } /** Builder to create a customized {@link RefWatcher}
with appropriate Android defaults. */ public static AndroidRefWatcherBuilder
refWatcher(Context context) { return new AndroidRefWatcherBuilder(context); }
可以看出LeakCanary使用了构建者模式去创建RefWatcher对象（实际上很多开源框架都使用了构建者模式去创建对象）。

listenerServiceClass方法是用来显示内存分析结果的，和原理联系不大。

excludedRefs则是排除了一些系统造成的内存泄漏，提高了检测精度。

下面我们分析buildAndInstall方法
public RefWatcher buildAndInstall() { RefWatcher refWatcher = build(); if
(refWatcher != DISABLED) { LeakCanary.enableDisplayLeakActivity(context);
ActivityRefWatcher.install((Application) context, refWatcher); } return
refWatcher; } public static void install(Application application, RefWatcher
refWatcher) { new ActivityRefWatcher(application,
refWatcher).watchActivities(); } public void watchActivities() { // Make sure
you don't get installed twice. stopWatchingActivities();
application.registerActivityLifecycleCallbacks(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) { } @Override
public void onActivityDestroyed(Activity activity) {
ActivityRefWatcher.this.onActivityDestroyed(activity); } }; void
onActivityDestroyed(Activity activity) { refWatcher.watch(activity); }

代码很清晰，build方法很简单，就是对一些参数的配置，重点在install方法。向Application注册一个Activity的生命周期回调，并且在onActivityDestroyed回调中调用watch方法进行监控，这也是之前提到的LeakCananry框架默认监控Activity的原因。

LeakCanary核心的代码在watch方法中
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); }

retainedKeys是一个Set集合，queue就是之前提到的引用队列。这里使用UUID为监控对象生成了一个唯一的key，并将key放入Set集合，同时创建了一个监控对象的弱引用。

准备工作做完了，下面开始对对象进行内存泄漏分析。
private void ensureGoneAsync(final long watchStartNanoTime, final
KeyedWeakReference reference) { watchExecutor.execute(new Retryable() {
@Override public Retryable.Result run() { return ensureGone(reference,
watchStartNanoTime); } }); } Retryable.Result ensureGone(final
KeyedWeakReference reference, final long watchStartNanoTime) { .....
removeWeaklyReachableReferences(); // 如果是debug模式，不进行分析 if
(debuggerControl.isDebuggerAttached()) { // The debugger can create false
leaks. return RETRY; } // 如果Set集合里不包含监控对象，那么说明已经分析过了，不需要再次分析 if
(gone(reference)) { return DONE; } // 手动触发GC gcTrigger.runGc();
removeWeaklyReachableReferences(); // 如果Set集合仍然包含监控对象，说明监控对象发生了内存泄漏 if
(!gone(reference)) { ..... } return DONE; } 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; while ((ref = (KeyedWeakReference) queue.poll()) != null) {
retainedKeys.remove(ref.key); } } private boolean gone(KeyedWeakReference
reference) { return !retainedKeys.contains(reference.key); }
启用了一个子线程去监控内存泄漏。


基本方法是手动触发GC，然后将引用队列里的元素出队列（GC后存在于引用队列说明被回收），从Set集合中将出队列的元素的key移除，如果移除后Set集合然后包含某对象的key值，说明该对象没有被回收，即发生了内存泄漏。

总结

1. 使用UUID为监控对象创建一个唯一的key值，并将key放入Set集合中。

2. 创建一个监控对象的弱引用，并开启线程进行内存分析。

3 手动触发GC，利用弱引用被回收会被放入引用队列的机制，将引用队列里的被回收对象出列，并从Set集合中移除对应的key值。

4 如果Set集合中监控对象的key值没有被移除，说明监控对象没有被放入引用队列，即没有被回收，发生了内存泄漏。

 

 

• « 上一篇：了解【Docker】从这里开始
• » 下一篇：IT人为了自己父母和家庭，更得注意自己的身体和心理健康