Android内存泄漏检测工具LeakCanary怎么使用

这篇“Android内存泄漏检测工具LeakCanary怎么使用”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“Android内存泄漏检测工具LeakCanary怎么使用”文章吧。

LeaksCanary 介绍

LeakCanary是Square公司为Android开发者提供的一个自动检测内存泄漏的工具。

LeakCanary本质上是一个基于MAT进行Android应用程序内存泄漏自动化检测的的开源工具，我们可以通过集成LeakCanary提供的jar包到自己的工程中，一旦检测到内存泄漏，LeakCanary就会dump Memory信息，并通过另一个进程分析内存泄漏的信息并展示出来，随时发现和定位内存泄漏问题，而不用每次在开发流程中都抽出专人来进行内存泄漏问题检测，极大地方便了Android应用程序的开发。

使用方法

1.LeakCanary 如何自动初始化

LeakCanary只需添加依赖就可以实现自动初始化。LeakCanary是通过ContentProvider实现初始化的，在ContentProvider 的 onCreate方法中初始化LeakCanary。并且MainProcessAppWatcherInstaller是在主线程中初始化的。注意：ContentProvider的初始化是在Application的onCreate之前完成的，所以LeakCanary的初始化方法AppWatcher.manualInstall(application)也是在Application的onCreate之前完成的。

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

@JvmOverloadsfun 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()  }}

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为例:

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方法检测。

fun interface ReachabilityWatcher {    fun expectWeaklyReachable(    watchedObject: Any,    description: String  )}ObjectWatcher.ktObjectWatcher实现ReachabilityWatcher接口。private val watchedObjects = mutableMapOf()private val queue = ReferenceQueue()@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)  }}

通过观察的实例watchedObject构建弱引用KeyedWeakReference实例，watchedObject与ReferenceQueue关联，当对象被回收时，该弱引用对象将被存入ReferenceQueue当中。

弱引用KeyedWeakReference实例会被被存储在watchedObjects中（Map）。

检测过程中，会调用removeWeaklyReachableObjects,将已回收对象从watchedObjects中移除。

如果watchedObjects中没有移除对象，证明它没有被回收，那么就会调用moveToRetained。

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)}

@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 发现一个对象只有弱引用，则就会回收此弱引用对象。

public class WeakReference<T> extends Reference<T> {    public WeakReference(T referent) {        super(referent);    }    public WeakReference(T referent, ReferenceQueue<? super T> q) {        super(referent, q);    }}

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 = nullSystem.gc()Handler().postDelayed( {    val weakReference_after_gc = weakReference.get()    Log.v("reference_tag", weakReference_after_gc.toString())}, 2000)

以上就是关于“Android内存泄漏检测工具LeakCanary怎么使用”这篇文章的内容，相信大家都有了一定的了解，希望小编分享的内容对大家有帮助，若想了解更多相关的知识内容，请关注编程网行业资讯频道。