1.LeakCanary 如何自动初始化
LeakCanary只需添加依赖就可以实现自动初始化。LeakCanary是通过ContentProvider实现初始化的，在ContentProvider 的 onCreate方法中初始化LeakCanary。并且MainProcessAppWatcherInstaller是在主线程中初始化的。注意：ContentProvider的初始化是在Application的onCreate之前完成的，所以LeakCanary的初始化方法AppWatcher.manualInstall(application)也是在Application的onCreate之前完成的。
|
1 2 3 4 5 6 7 8 |
internal class MainProcessAppWatcherInstaller : ContentProvider() { override fun onCreate(): Boolean { val application = context!!.applicationContext as Application AppWatcher.manualInstall(application) return true } ... ... } |
2.LeakCanary如何检测内存泄漏
2.1LeakCanary初始化时做了什么
AppWatcher.kt
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
@JvmOverloads fun manualInstall( application: Application, retainedDelayMillis: Long = TimeUnit.SECONDS.toMillis(5), watchersToInstall: List<InstallableWatcher> = appDefaultWatchers(application) ) { checkMainThread() if (isInstalled) { throw IllegalStateException( "AppWatcher already installed, see exception cause for prior install call", installCause ) } check(retainedDelayMillis >= 0) { "retainedDelayMillis $retainedDelayMillis must be at least 0 ms" } installCause = RuntimeException("manualInstall() first called here") this.retainedDelayMillis = retainedDelayMillis if (application.isDebuggableBuild) { LogcatSharkLog.install() } // Requires AppWatcher.objectWatcher to be set LeakCanaryDelegate.loadLeakCanary(application) watchersToInstall.forEach { it.install() } } |
|
1 2 3 4 5 6 7 8 9 10 11 |
fun appDefaultWatchers( application: Application, reachabilityWatcher: ReachabilityWatcher = objectWatcher ): List<InstallableWatcher> { return listOf( ActivityWatcher(application, reachabilityWatcher), FragmentAndViewModelWatcher(application, reachabilityWatcher), RootViewWatcher(reachabilityWatcher), ServiceWatcher(reachabilityWatcher) ) } |
在appDefaultWatchers方法中，会默认初始化一些Watcher，在默认情况下，我们只会监控Activity,Fragment,RootView,Service这些对象是否泄漏。
2.2LeakCanary如何触发检测
以ActivityWatcher为例:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
/** * Expects activities to become weakly reachable soon after they receive the [Activity.onDestroy] * callback. */ class ActivityWatcher( private val application: Application, private val reachabilityWatcher: ReachabilityWatcher ) : InstallableWatcher { private val lifecycleCallbacks = object : Application.ActivityLifecycleCallbacks by noOpDelegate() { override fun onActivityDestroyed(activity: Activity) { reachabilityWatcher.expectWeaklyReachable( activity, "${activity::class.java.name} received Activity#onDestroy() callback" ) } } override fun install() { application.registerActivityLifecycleCallbacks(lifecycleCallbacks) } override fun uninstall() { application.unregisterActivityLifecycleCallbacks(lifecycleCallbacks) } } |
在Activity.onDestory时，就会触发检测内存泄漏。通过ActivityLifecycleCallbacks监听生命周期变化，在onActivityDestroyed方法中调用ReachabilityWatcher的expectWeaklyReachable方法。
2.3LeakCanary如何检测泄漏的对象
以Activity为例，通过ReachabilityWatcher的expectWeaklyReachable方法检测。
|
1 2 3 4 5 6 7 8 9 10 |
fun interface ReachabilityWatcher { /** * Expects the provided [watchedObject] to become weakly reachable soon. If not, * [watchedObject] will be considered retained. */ fun expectWeaklyReachable( watchedObject: Any, description: String ) } |
ObjectWatcher.kt
ObjectWatcher实现ReachabilityWatcher接口。
private val watchedObjects = mutableMapOf()
private val queue = ReferenceQueue()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
@Synchronized override fun expectWeaklyReachable( watchedObject: Any, description: String ) { if (!isEnabled()) { return } removeWeaklyReachableObjects() val key = UUID.randomUUID() .toString() val watchUptimeMillis = clock.uptimeMillis() val reference = KeyedWeakReference(watchedObject, key, description, watchUptimeMillis, queue) SharkLog.d { "Watching " + (if (watchedObject is Class<*>) watchedObject.toString() else "instance of ${watchedObject.javaClass.name}") + (if (description.isNotEmpty()) " ($description)" else "") + " with key $key" } watchedObjects[key] = reference checkRetainedExecutor.execute { moveToRetained(key) } } |
1.通过观察的实例watchedObject构建弱引用KeyedWeakReference实例，watchedObject与ReferenceQueue关联，当对象被回收时，该弱引用对象将被存入ReferenceQueue当中。
2.弱引用KeyedWeakReference实例会被被存储在watchedObjects中（Map）。
3.检测过程中，会调用removeWeaklyReachableObjects,将已回收对象从watchedObjects中移除。
4.如果watchedObjects中没有移除对象，证明它没有被回收，那么就会调用moveToRetained。
|
1 2 3 4 5 6 7 8 9 10 11 |
private fun removeWeaklyReachableObjects() { // 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. var ref: KeyedWeakReference? do { ref = queue.poll() as KeyedWeakReference? if (ref != null) { watchedObjects.remove(ref.key) } } while (ref != null) } |
|
1 2 3 4 5 6 7 8 |
@Synchronized private fun moveToRetained(key: String) { removeWeaklyReachableObjects() val retainedRef = watchedObjects[key] if (retainedRef != null) { retainedRef.retainedUptimeMillis = clock.uptimeMillis() onObjectRetainedListeners.forEach { it.onObjectRetained() } } } |
2.4弱引用 WeakReference
只要 GC 发现一个对象只有弱引用，则就会回收此弱引用对象。
|
1 2 3 4 5 6 7 8 |
public class WeakReference<T> extends Reference<T> { public WeakReference(T referent) { super(referent); } public WeakReference(T referent, ReferenceQueue<? super T> q) { super(referent, q); } } |
|
1 2 3 4 5 6 7 8 9 10 11 |
var str: Any? = Any() val quque = ReferenceQueue<Any>() val weakReference = WeakReference<Any>(str, quque) val weakReference_before_gc = weakReference.get() Log.v("reference_tag", weakReference_before_gc.toString()) str = null System.gc() Handler().postDelayed( { val weakReference_after_gc = weakReference.get() Log.v("reference_tag", weakReference_after_gc.toString()) }, 2000) |
2022-02-27 17:43:04.181 16634-16634/com.example.myapplication V/reference_tag: java.lang.Object@c87946a
2022-02-27 17:43:06.182 16634-16634/com.example.myapplication V/reference_tag: null
