Android内存泄露检测 LeakCanary2.0(Kotlin版)的实现原理

dependencies {  // debugImplementation because LeakCanary should only run in debug builds.  debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.5'}

internal sealed class AppWatcherInstaller : ContentProvider() {   /**   * [MainProcess] automatically sets up the LeakCanary code that runs in the main app process.   */  internal class MainProcess : AppWatcherInstaller()   /**   * When using the `leakcanary-android-process` artifact instead of `leakcanary-android`,   * [LeakCanaryProcess] automatically sets up the LeakCanary code   */  internal class LeakCanaryProcess : AppWatcherInstaller()   override fun onCreate(): Boolean {    val application = context!!.applicationContext as Application    AppWatcher.manualInstall(application)    return true  }  //....}

AppWatcher.objectWatcher.watch(myDetachedView, "View was detached")

//InternalAppWatcher初始化fun install(application: Application) {         ......         val configProvider = { AppWatcher.config }    ActivityDestroyWatcher.install(application, objectWatcher, configProvider)    FragmentDestroyWatcher.install(application, objectWatcher, configProvider)    onAppWatcherInstalled(application)  } //InternalleakCanary初始化override fun invoke(application: Application) {    _application = application    checkRunningInDebuggableBuild()     AppWatcher.objectWatcher.addOnObjectRetainedListener(this)     val heapDumper = AndroidHeapDumper(application, createLeakDirectoryProvider(application))     val gcTrigger = GcTrigger.Default     val configProvider = { LeakCanary.config }    //异步线程执行耗时操作    val handlerThread = HandlerThread(LEAK_CANARY_THREAD_NAME)    handlerThread.start()    val backgroundHandler = Handler(handlerThread.looper)     heapDumpTrigger = HeapDumpTrigger(        application, backgroundHandler, AppWatcher.objectWatcher, gcTrigger, heapDumper,        configProvider    )    //Application 可见性监听    application.registerVisibilityListener { applicationVisible ->      this.applicationVisible = applicationVisible      heapDumpTrigger.onApplicationVisibilityChanged(applicationVisible)    }    registerResumedActivityListener(application)    addDynamicShortcut(application)     disableDumpHeapInTests()  }

@Synchronized fun watch(    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)    }  }

private fun checkRetainedObjects(reason: String) {    val config = configProvider()    // A tick will be rescheduled when this is turned back on.    if (!config.dumpHeap) {      SharkLog.d { "Ignoring check for retained objects scheduled because $reason: LeakCanary.Config.dumpHeap is false" }      return    }     //第一次移除不可达对象    var retainedReferenceCount = objectWatcher.retainedObjectCount     if (retainedReferenceCount > 0) {        //主动出发GC      gcTrigger.runGc()        //第二次移除不可达对象      retainedReferenceCount = objectWatcher.retainedObjectCount    }     //判断是否还有剩余的监听对象存活，且存活的个数是否超过阈值    if (checkRetainedCount(retainedReferenceCount, config.retainedVisibleThreshold)) return     ....     SharkLog.d { "Check for retained objects found $retainedReferenceCount objects, dumping the heap" }    dismissRetainedCountNotification()    dumpHeap(retainedReferenceCount, retry = true)  }

//HeapDumpTriggerprivate fun dumpHeap(    retainedReferenceCount: Int,    retry: Boolean  ) {         ....          HeapAnalyzerService.runAnalysis(application, heapDumpFile)  }

//HeapAnalyzerServiceprivate fun analyzeHeap(    heapDumpFile: File,    config: Config  ): HeapAnalysis {    val heapAnalyzer = HeapAnalyzer(this)     val proguardMappingReader = try {        //解析混淆文件      ProguardMappingReader(assets.open(PROGUARD_MAPPING_FILE_NAME))    } catch (e: IOException) {      null    }    //分析hprof文件    return heapAnalyzer.analyze(        heapDumpFile = heapDumpFile,        leakingObjectFinder = config.leakingObjectFinder,        referenceMatchers = config.referenceMatchers,        computeRetainedHeapSize = config.computeRetainedHeapSize,        objectInspectors = config.objectInspectors,        metadataExtractor = config.metadataExtractor,        proguardMapping = proguardMappingReader?.readProguardMapping()    )  }

fun analyze(   heapDumpFile: File,   leakingObjectFinder: LeakingObjectFinder,   referenceMatchers: List<ReferenceMatcher> = emptyList(),   computeRetainedHeapSize: Boolean = false,   objectInspectors: List<ObjectInspector> = emptyList(),   metadataExtractor: MetadataExtractor = MetadataExtractor.NO_OP,   proguardMapping: ProguardMapping? = null ): HeapAnalysis {   val analysisStartNanoTime = System.nanoTime()    if (!heapDumpFile.exists()) {     val exception = IllegalArgumentException("File does not exist: $heapDumpFile")     return HeapAnalysisFailure(         heapDumpFile, System.currentTimeMillis(), since(analysisStartNanoTime),         HeapAnalysisException(exception)     )   }    return try {     listener.onAnalysisProgress(PARSING_HEAP_DUMP)     Hprof.open(heapDumpFile)         .use { hprof ->           val graph = HprofHeapGraph.indexHprof(hprof, proguardMapping)//建立gragh           val helpers =             FindLeakInput(graph, referenceMatchers, computeRetainedHeapSize, objectInspectors)           helpers.analyzeGraph(//分析graph               metadataExtractor, leakingObjectFinder, heapDumpFile, analysisStartNanoTime           )         }   } catch (exception: Throwable) {     HeapAnalysisFailure(         heapDumpFile, System.currentTimeMillis(), since(analysisStartNanoTime),         HeapAnalysisException(exception)     )   } }

interface HeapGraph {  val identifierByteSize: Int  /**   * In memory store that can be used to store objects this [HeapGraph] instance.   */  val context: GraphContext  /**   * All GC roots which type matches types known to this heap graph and which point to non null   * references. You can retrieve the object that a GC Root points to by calling [findObjectById]   * with [GcRoot.id], however you need to first check that [objectExists] returns true because   * GC roots can point to objects that don't exist in the heap dump.   */  val gcRoots: List<GcRoot>  /**   * Sequence of all objects in the heap dump.   *   * This sequence does not trigger any IO reads.   */  val objects: Sequence<HeapObject>  //所有对象的序列，包括类对象、实例对象、对象数组、原始类型数组   val classes: Sequence<HeapClass>   //类对象序列   val instances: Sequence<HeapInstance>   //实例对象数组   val objectArrays: Sequence<HeapObjectArray>  //对象数组序列     val primitiveArrays: Sequence<HeapPrimitiveArray>   //原始类型数组序列}

//PathFinderprivate fun State.findPathsFromGcRoots(): PathFindingResults {    enqueueGcRoots()//1     val shortestPathsToLeakingObjects = mutableListOf<ReferencePathNode>()    visitingQueue@ while (queuesNotEmpty) {      val node = poll()//2       if (checkSeen(node)) {//2        throw IllegalStateException(            "Node $node objectId=${node.objectId} should not be enqueued when already visited or enqueued"        )      }       if (node.objectId in leakingObjectIds) {//3        shortestPathsToLeakingObjects.add(node)        // Found all refs, stop searching (unless computing retained size)        if (shortestPathsToLeakingObjects.size == leakingObjectIds.size) {//4          if (computeRetainedHeapSize) {            listener.onAnalysisProgress(FINDING_DOMINATORS)          } else {            break@visitingQueue          }        }      }       when (val heapObject = graph.findObjectById(node.objectId)) {//5        is HeapClass -> visitClassRecord(heapObject, node)        is HeapInstance -> visitInstance(heapObject, node)        is HeapObjectArray -> visitObjectArray(heapObject, node)      }    }    return PathFindingResults(shortestPathsToLeakingObjects, dominatedObjectIds)  }