android开发分享Android 进阶实现性能优化之OOM与Leakcanary详解原理

目录

• android内存泄漏常见场景以及解决方案
• 资源性对象未关闭
• 注册对象未注销
• 类的静态变量持有大数据
• 单例造成的内存泄漏
• 非静态内部类的静态实例
• handler临时性内存泄漏
• 容器中的对象没清理造成的内存泄漏
• webview
• 使用listview时造成的内存泄漏
• leakcanary
• leakcanary 导入
• leakcanary 是如何安装的
• leakcanary 如何监听activity、fragment销毁
• refwatcher 核心原理
• 流程图

  //  leakcanary 添加支持库即可，只在debug下使用  debugimplementation 'com.squareup.leakcanary:leakcanary-android:2.3'  

  //	package="com.squareup.leakcanary.leaksentry"    <application>      <provider          android:name="leakcanary.internal.leaksentryinstaller"          android:authorities="${applicationid}.leak-sentry-installer"          android:exported="false"/>    </application>  

  internal class leaksentryinstaller : contentprovider() {      override fun oncreate(): boolean {      canarylog.logger = defaultcanarylog()      val application = context!!.applicationcontext as application       // 进行初始化工作，核心      internalleaksentry.install(application)      return true    }  

    fun install(application: application) {      canarylog.d("installing leaksentry")      // 只能在主线程调用，否则会抛出异常      checkmainthread()      if (this::application.isinitialized) {        return      }      internalleaksentry.application = application        val configprovider = { leaksentry.config }      // 监听 activity.ondestroy()      activitydestroywatcher.install(          application, refwatcher, configprovider      )      // 监听 fragment.ondestroy()      fragmentdestroywatcher.install(          application, refwatcher, configprovider      )      // sentry 哨兵      listener.onleaksentryinstalled(application)    }  

  // activitylifecyclecallbacks 接口  public interface activitylifecyclecallbacks {      void onactivitycreated(activity var1, bundle var2);        void onactivitystarted(activity var1);        void onactivityresumed(activity var1);        void onactivitypaused(activity var1);        void onactivitystopped(activity var1);        void onactivitysaveinstancestate(activity var1, bundle var2);        void onactivitydestroyed(activity var1);  }  // fragmentlifecyclecallbacks 接口  public abstract static class fragmentlifecyclecallbacks {        public void onfragmentcreated(fragmentmanager fm, fragment f, bundle savedinstancestate) {}        public void onfragmentviewdestroyed(fragmentmanager fm, fragment f) {}        public void onfragmentdestroyed(fragmentmanager fm, fragment f) {}        // 省略其他的生命周期 ...    }  

  internal class activitydestroywatcher private constructor(    private val refwatcher: refwatcher,    private val configprovider: () -> config  ) {      private val lifecyclecallbacks = object : activitylifecyclecallbacksadapter() {      override fun onactivitydestroyed(activity: activity) {        if (configprovider().watchactivities) {          // 监听到 ondestroy() 之后，通过 refwatcher 监测 activity          refwatcher.watch(activity)        }      }    }      companion object {      fun install(        application: application,        refwatcher: refwatcher,        configprovider: () -> config      ) {        val activitydestroywatcher =          activitydestroywatcher(refwatcher, configprovider)        // 注册 activity 生命周期监听        application.registeractivitylifecyclecallbacks(activitydestroywatcher.lifecyclecallbacks)      }    }  }  

    @synchronized fun watch(      watchedreference: any,      referencename: string    ) {      if (!isenabled()) {        return      }      // 移除队列中将要被 gc 的引用      removeweaklyreachablereferences()       val key = uuid.randomuuid().tostring()      val watchuptimemillis = clock.uptimemillis()      // 构建当前引用的弱引用对象，并关联引用队列 queue      val reference = keyedweakreference(watchedreference, key, referencename, watchuptimemillis, queue)      if (referencename != "") {        canarylog.d(            "watching instance of %s named %s with key %s", reference.classname,            referencename, key        )      } else {        canarylog.d(            "watching instance of %s with key %s", reference.classname, key        )      }      // 将引用存入 watchedreferences      watchedreferences[key] = reference       checkretainedexecutor.execute {        // 如果当前引用未被移除，仍在 watchedreferences  队列中，        // 说明仍未被 gc，移入 retainedreferences 队列中,暂时标记为泄露        movetoretained(key)       }    }  

    private fun 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.      // 弱引用一旦变得弱可达，就会立即入队。这将在 finalization 或者 gc 之前发生。      var ref: keyedweakreference?      do {        // 队列 queue 中的对象都是会被 gc 的        ref = queue.poll() as keyedweakreference?         //说明被释放了        if (ref != null) {          val removedref = watchedreferences.remove(ref.key)//获取被释放的引用的key          if (removedref == null) {            retainedreferences.remove(ref.key)          }          // 移除 watchedreferences 队列中的会被 gc 的 ref 对象，剩下的就是可能泄露的对象        }      } while (ref != null)    }  

    @synchronized private fun movetoretained(key: string) {      // 再次调用，防止遗漏      removeweaklyreachablereferences()       val retainedref = watchedreferences.remove(key)      //说明可能存在内存泄漏      if (retainedref != null) {        retainedreferences[key] = retainedref        onreferenceretained()      }    }  

    private fun checkretainedinstances(reason: string) {      canarylog.d("checking retained instances because %s", reason)      val config = configprovider()      // a tick will be rescheduled when this is turned back on.      if (!config.dumpheap) {        return      }        var retainedkeys = refwatcher.retainedkeys        // 当前泄露实例个数小于 5 个，不进行 heap dump      if (checkretainedcount(retainedkeys, config.retainedvisiblethreshold)) return        if (!config.dumpheapwhendebugging && debuggercontrol.isdebuggerattached) {        showretainedcountwithdebuggerattached(retainedkeys.size)        scheduleretainedinstancecheck("debugger was attached", wait_for_debug_millis)        canarylog.d(            "not checking for leaks while the debugger is attached, will retry in %d ms",            wait_for_debug_millis        )        return      }        // 可能存在被观察的引用将要变得弱可达，但是还未入队引用队列。      // 这时候应该主动调用一次 gc，可能可以避免一次 heap dump      gctrigger.rungc()        retainedkeys = refwatcher.retainedkeys        if (checkretainedcount(retainedkeys, config.retainedvisiblethreshold)) return        heapdumpmemorystore.setretainedkeysforheapdump(retainedkeys)        canarylog.d("found %d retained references, dumping the heap", retainedkeys.size)      heapdumpmemorystore.heapdumpuptimemillis = systemclock.uptimemillis()      dismissnotification()      val heapdumpfile = heapdumper.dumpheap() // androidheapdumper      if (heapdumpfile == null) {        canarylog.d("failed to dump heap, will retry in %d ms", wait_after_dump_failed_millis)        scheduleretainedinstancecheck("failed to dump heap", wait_after_dump_failed_millis)        showretainedcountwithheapdumpfailed(retainedkeys.size)        return      }        refwatcher.removeretainedkeys(retainedkeys) // 移除已经 heap dump 的 retainedkeys        heapanalyzerservice.runanalysis(application, heapdumpfile) // 分析 heap dump 文件    }