LeakCanary原理解析，理解起来超简单！

@Override public void onActivityDestroyed(Activity activity) {

//当Activity销毁时调用refWathcer的watch方法观察这个对象

refWatcher.watch(activity);

}

};

（6） FragmentRefWatcher.Helper.install(context, refWatcher);

public static void install(Context context, RefWatcher refWatcher) {

//创建一个集合

List fragmentRefWatchers = new ArrayList<>();

//如果当前API版本大于26，创建一个AndroidOFragmentRefWatcher对象加入到集合中

if (SDK_INT >= O) {

fragmentRefWatchers.add(new AndroidOFragmentRefWatcher(refWatcher));

}

try {

//找到SupportFragmentRefWatcher这个类

Class<?> fragmentRefWatcherClass = Class.forName(SUPPORT_FRAGMENT_REF_WATCHER_CLASS_NAME);

//找到它的构造方法

Constructor<?> constructor =

fragmentRefWatcherClass.getDeclaredConstructor(RefWatcher.class);

//创建SupportFragmentRefWatcher实例，并添加到集合中

FragmentRefWatcher supportFragmentRefWatcher =

(FragmentRefWatcher) constructor.newInstance(refWatcher);

fragmentRefWatchers.add(supportFragmentRefWatcher);

} catch (Exception ignored) {

}

if (fragmentRefWatchers.size() == 0) {

return;

}

Helper helper = new Helper(fragmentRefWatchers);

Application application = (Application) context.getApplicationContext();

application.registerActivityLifecycleCallbacks(helper.activityLifecycleCallbacks);

}

这个方法的作用是当当前API版本大于26的时候,在Activity销毁是它会调用AndroidOFragmentRefWatcher的watchFragments方法观察当前Activity中的所有销毁的Fragments。也就是说如果当前API版本是大于26的，我们不需要在在Fragment的onDestory方法中自己调用RefWatcher的watch方法了。

下面我们来分析RefWatcher的watch方法,这个方法是LeakCanary的核心逻辑所在，我们一起来看看吧。

3.RefWatcher.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();

//生成一个随机数作为key

String key = UUID.randomUUID().toString();

//retainedKeys是一个Set集合，存储所有的key

retainedKeys.add(key);

//使用KeyedWeakReference包装当前传过来的引用，代指Activity和Fragment

//注意了这里传了一个queue，即ReferenceQueue,所以如果KeyedWeakReference引用的Activity或者

//Fragment即将被销毁时，就会向这个queue中添加reference这个引用对象。

final KeyedWeakReference reference =

new KeyedWeakReference(watchedReference, key, referenceName, queue);

ensureGoneAsync(watchStartNanoTime, reference);

}

4.ensureGoneAsync()

private void ensureGoneAsync(final long watchStartNanoTime, final KeyedWeakReference reference) {

watchExecutor.execute(new Retryable() {

@Override public Retryable.Result run() {

return ensureGone(reference, watchStartNanoTime);

}

});

}

这里主要就是调用watchExecutor的execute添加了一个Retryable任务，有点类似与线程池。这边的watchExecutor是通过RefWathcer的构造方法传过来的。通过上面的分析，我们知道在一开始创建了一个AndroidRefWatcherBuilder对象，它会调用的buildAndInstall方法，这个方法中我们调用了build()方法创建了RefWatcher对象，现在我们去看看这个RefWathcer是怎么创建的。

5.build（）

public final RefWatcher build() {

if (isDisabled()) {

return RefWatcher.DISABLED;

}

if (heapDumpBuilder.excludedRefs == null) {

heapDumpBuilder.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) {

//调用的是AndroidRefWatcherBuilder中的方法。所以这里创建的是一个AndroidHeapDumper对象

heapDumper = defaultHeapDumper();

}

WatchExecutor watchExecutor = this.watchExecutor;

if (watchExecutor == null) {

//调用的是AndroidRefWatcherBuilder中的方法。所以这里创建的是一个AndroidWatchExecutor对象

watchExecutor = defaultWatchExecutor();

}

GcTrigger gcTrigger = this.gcTrigger;

if (gcTrigger == null) {

//创建的是GcTrigger DEFAULT这个对象

gcTrigger = defaultGcTrigger();

}

if (heapDumpBuilder.reachabilityInspectorClasses == null) {

heapDumpBuilder.reachabilityInspectorClasses(defaultReachabilityInspectorClasses());

}

return new RefWatcher(watchExecutor, debuggerControl, gcTrigger, heapDumper, heapDumpListener,

heapDumpBuilder);

}

这里注意了，AndroidRefWatcherBuilder类中没用实现build方法，所有是调用父类RefWatcherBuilder中的build方法，但是AndroidRefWatcherBuilder实现了defaultWatchExecutor，defaultHeapDumpListener这些方法，所以这些方法应该调用的是AndroidRefWatcherBuilder中的，而不是RefWatcherBuilder的。

6.AndroidWatchExecutor.execute()

通过5的分析我们知道RefWatcher中的watchExecutor对象其实是AndroidWatchExecutor类型的，下面我们来看看它的execute方法做了什么事。

@Override public void execute(Retryable retryable) {

//如果当前线程是主线程

if (Looper.getMainLooper().getThread() == Thread.currentThread()) {

waitForIdle(retryable, 0);

} else {

postWaitForIdle(retryable, 0);

}

}

我们看到，这里分了两种情况去做处理。如果当前线程是主线程调用 waitForIdle(retryable, 0);否则调用postWaitForIdle(retryable, 0);。其实不管怎么样最终调用的都是waitForIdle这个方法。

1.waitForIdle(retryable, 0);

private void waitForIdle(final Retryable retryable, final int failedAttempts) {

//向主线程的消息队列中里添加了一个对象

//当我们注册了IdleHandler的时候，当主线程空闲时，会发送一个空闲消息来执行IdleHandler中的回调

//注意了，queueIdle这个返回为false是，表示只会执行一次，如果为true代表，如果主线程每次空闲时都会

//执行这个方法

Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() {

@Override public boolean queueIdle() {

//当主线程空闲时调用postToBackgroundWithDelay方法

postToBackgroundWithDelay(retryable, failedAttempts);

return false;

}

});

}

private void postToBackgroundWithDelay(final Retryable retryable, final int failedAttempts) {

long exponentialBackoffFactor = (long) Math.min(Math.pow(2, failedAttempts), maxBackoffFactor);

long delayMillis = initialDelayMillis * exponentialBackoffFactor;

//backgroundHandler是一个与异步线程绑定的Handler，我们可以看下AndroidWatchExecutor的构造方法中

//创建了一个HandlerThread，自己内部构建了一个异步的消息循环

//所以retryable.run()方法是执行在异步线程中的

backgroundHandler.postDelayed(new Runnable() {

@Override public void run() {

Retryable.Result result = retryable.run();

if (result == RETRY) {

postWaitForIdle(retryable, failedAttempts + 1);

}

}

}, delayMillis);

}

7.retryable.run() ->ensureGone

上面分析了那么多，其实这里才是我们的主要逻辑，我们先把涉及到的关键代码，贴出来，一步步来分析。

@SuppressWarnings(“ReferenceEquality”) // Explicitly checking for named null.

Retryable.Result ensureGone(final KeyedWeakReference reference, final long watchStartNanoTime) {

long gcStartNanoTime = System.nanoTime();

long watchDurationMs = NANOSECONDS.toMillis(gcStartNanoTime - watchStartNanoTime);

//如果对象GC时被回收了，就移除retainedKeys中对应的key值

removeWeaklyReachableReferences();

if (debuggerControl.isDebuggerAttached()) {

// The debugger can create false leaks.

return RETRY;

}

//如果retainedKeys还存在观察对象的key值代表没有被回收

if (gone(reference)) {

return DONE;

}

//第一次检查没有被回收手动触发GC

gcTrigger.runGc();

//GC完毕之后再去检查

removeWeaklyReachableReferences();

//如果GC后retainedKeys还存在观察对象的key。则表示发生了内存泄漏。

if (!gone(reference)) {

long startDumpHeap = System.nanoTime();

long gcDurationMs = NANOSECONDS.toMillis(startDumpHeap - gcStartNanoTime);

//dump生成文件

File heapDumpFile = heapDumper.dumpHeap();

if (heapDumpFile == RETRY_LATER) {

// Could not dump the heap.

return RETRY;

}

long heapDumpDurationMs = NANOSECONDS.toMillis(System.nanoTime() - startDumpHeap);

//创建了HeapDump对象

HeapDump heapDump = heapDumpBuilder.heapDumpFile(heapDumpFile).referenceKey(reference.key)

.referenceName(reference.name)

.watchDurationMs(watchDurationMs)

.gcDurationMs(gcDurationMs)

.heapDumpDurationMs(heapDumpDurationMs)

.build();

//回调ServiceHeapDumpListener的analyze方法，然后调用HeapAnalyzerService.runAnalysis的静态方法

//启动自身去分析HeapDump，使用HaHa库。不在做分析，感兴趣的朋友可以自己去研究研究。

heapdumpListener.analyze(heapDump);

}

return DONE;

}

private boolean gone(KeyedWeakReference reference) {

//判断是否还存在当前引用的key

//如果存在代表没有被回收

//不存在代表被回收了

return !retainedKeys.contains(reference.key);

}

private void removeWeaklyReachableReferences() {

//如果队列中有元素，代表GC是已经将对象给回收掉

//每从队列中去除一个元素，同时在retainedKeys这个集合中移除相应的key值。

KeyedWeakReference ref;

while ((ref = (KeyedWeakReference) queue.poll()) != null) {

retainedKeys.remove(ref.key);

}

}

GcTrigger DEFAULT = new GcTrigger() {

@Override public void runGc() {

// Code taken from AOSP FinalizationTest:

// https://android.googlesource.com/platform/libcore/+/master/support/src/test/java/libcore/

// java/lang/ref/FinalizationTester.java

// System.gc() does not garbage collect every time. Runtime.gc() is

// more likely to perfom a gc.

//这里为什没有调用System.gc()呢，注释已经给了我们说明

//Runtime.gc()比起System.gc()更有可能去触发一次GC，注意并不是百分百触发GC

Runtime.getRuntime().gc();

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

结语

• 现在随着短视频，抖音，快手的流行NDK模块开发也显得越发重要，需要这块人才的企业也越来越多，随之学习这块的人也变多了，音视频的开发，往往是比较难的，而这个比较难的技术就是NDK里面的技术。
• 音视频/高清大图片/人工智能/直播/抖音等等这年与用户最紧密，与我们生活最相关的技术一直都在寻找最终的技术落地平台，以前是windows系统，而现在则是移动系统了，移动系统中又是以Android占比绝大部分为前提，所以AndroidNDK技术已经是我们必备技能了。
• 要学习好NDK，其中的关于C/C++，jni，Linux基础都是需要学习的，除此之外，音视频的编解码技术，流媒体协议，ffmpeg这些都是音视频开发必备技能，而且
• OpenCV/OpenGl/这些又是图像处理必备知识，下面这些我都是当年自己搜集的资料和做的一些图，因为当年我就感觉视频这块会是一个大的趋势。所以提前做了一些准备。现在拿出来分享给大家。

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

开发也显得越发重要，需要这块人才的企业也越来越多，随之学习这块的人也变多了，音视频的开发，往往是比较难的，而这个比较难的技术就是NDK里面的技术。

• 音视频/高清大图片/人工智能/直播/抖音等等这年与用户最紧密，与我们生活最相关的技术一直都在寻找最终的技术落地平台，以前是windows系统，而现在则是移动系统了，移动系统中又是以Android占比绝大部分为前提，所以AndroidNDK技术已经是我们必备技能了。
• 要学习好NDK，其中的关于C/C++，jni，Linux基础都是需要学习的，除此之外，音视频的编解码技术，流媒体协议，ffmpeg这些都是音视频开发必备技能，而且
• OpenCV/OpenGl/这些又是图像处理必备知识，下面这些我都是当年自己搜集的资料和做的一些图，因为当年我就感觉视频这块会是一个大的趋势。所以提前做了一些准备。现在拿出来分享给大家。

[外链图片转存中…(img-XTqde1Ly-1712781950923)]

[外链图片转存中…(img-kHrFJ3Oy-1712781950923)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！