ukyoo
ukyoo

LeakCanary2.0源码解析

LeakCanary是使用成本较低的HeapProfiler, 通常内存泄漏都比较隐蔽, 和OOM后再去分析hprof文件不同,他能在开发过程中帮助我们及时发现可能泄露的问题.

原理

LeakCanary的原理很简单: 在Activity或Fragment被销毁后, 将他们的引用包装成一个WeakReference, 然后将这个WeakReference关联到一个ReferenceQueue.查看ReferenceQueue中是否含有Activity或Fragment的引用, 如果没有触发GC,再次查看,还是没有的话就说明没有回收成功, 可能发生了泄露. 这时候开始dump内存的信息,并分析泄露的引用链.

使用

LeakCanary现在已经有2.0的canary版本.实现和上个版本1.6相比也有不同.
2.0以前

"leakcanary"          : 'com.squareup.leakcanary:leakcanary-android:1.5',
"leakcanary_no"       : 'com.squareup.leakcanary:leakcanary-android-no-op:1.5'

public class MyApp extends MultiDexApplication {
    @Override
    public void onCreate() {
        super.onCreate();
        //2.0之前LeakCanary是在单独的进程里来分析的
        if (LeakCanary.isInAnalyzerProcess(this)) {
          return;
        }
        LeakCanary.install(this);
    }
}

2.0

debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.0-alpha-2'

区别

  • 配合Gradle3.0引入的debugImplementation我们不需要添加no-op包来分离测试和生产环境了.
  • LeakCanary也不需要再单独的进程里来分析了,2.0之前的版本AS里可以看到LeakCanary是单独开了一个进程的
  • 2.0不再需要我们手动执行初始化了, 我们看看2.0自动注册的实现.

自动注册的实现

查看leakCanary-android ->引用了 leakcanary-android-core →引用了leakcanary-leaksentry
查看leakcanary-leaksentry的AndroidManifest.xml文件

LeakSentryInstaller继承了ContentProvider, 在onCreate()方法里调用了InternalLeakSentry.install(application)

/**
 * Content providers are loaded before the application class is created. [LeakSentryInstaller] is
 * used to install [leaksentry.LeakSentry] on application start.
 */
internal class LeakSentryInstaller : ContentProvider() {

  override fun onCreate(): Boolean {
    CanaryLog.logger = DefaultCanaryLog()
    val application = context!!.applicationContext as Application
    //在contentProvider初始化的时候, 初始化LeakCanary
    InternalLeakSentry.install(application)
    return true
  }

  override fun query(
    uri: Uri,
    strings: Array?,
    s: String?,
    strings1: Array?,
    s1: String?
  ): Cursor? {
    return null
  }

  override fun getType(uri: Uri): String? {
    return null
  }

  override fun insert(
    uri: Uri,
    contentValues: ContentValues?
  ): Uri? {
    return null
  }

  override fun delete(
    uri: Uri,
    s: String?,
    strings: Array?
  ): Int {
    return 0
  }

  override fun update(
    uri: Uri,
    contentValues: ContentValues?,
    s: String?,
    strings: Array?
  ): Int {
    return 0
  }
}

APP构建经过manifest-merge后官方文档-合并多个清单文件,这个ContentProvider会被合并到唯一的manifest.xml中. 当APP初始化时会加载这个LeakSentryInstaller,就会自动帮我们执行InternalLeakSentry.install(application)

作为ContentProvider他的其他CRUD实现都是空的.作者只是巧妙利用了ContentProvider无需显式初始化的特性(对比Service,BroadcastReceiver)来实现了自动注册.

源码分析

1、InternalLeakSentry#install

这里初始化了RefWatcher,

internal object InternalLeakSentry {
  private val checkRetainedExecutor = Executor {
    //这里的Executor收到任务后, 延迟watchDurationMillis秒后执行,这里默认是5秒
    mainHandler.postDelayed(it, LeakSentry.config.watchDurationMillis)
  }
  //初始化RefWatcher
  val refWatcher = RefWatcher(
      clock = clock,
      checkRetainedExecutor = checkRetainedExecutor,
      onReferenceRetained = { listener.onReferenceRetained() },
      isEnabled = { LeakSentry.config.enabled } //默认true
  )
  
  //初始化LeakSentryListener
  private val listener: LeakSentryListener
  init {
    listener = try {
      //反射得到LeakSentryListener实现类: InternalLeakCanary实例
      val leakCanaryListener = Class.forName("leakcanary.internal.InternalLeakCanary")
      leakCanaryListener.getDeclaredField("INSTANCE").get(null) as LeakSentryListener
    } catch (ignored: Throwable) {
      LeakSentryListener.None
    }
  }

  fun install(application: Application) {
    CanaryLog.d("Installing LeakSentry")
    //需要在主线程初始化
    checkMainThread()  
    //避免重复初始化
    if (this::application.isInitialized) {
      return
    }
    InternalLeakSentry.application = application
    //可以通过LeakSentry.config来修改watchFragments, watchDurationMillis等参数
    val configProvider = { LeakSentry.config }
    //注册ActivityDestroyWatcher
    ActivityDestroyWatcher.install(
        application, refWatcher, configProvider
    )
    //注册FragmentDestroyWatcher
    FragmentDestroyWatcher.install(
        application, refWatcher, configProvider
    )
    //LeakSentry初始化完成回调
    listener.onLeakSentryInstalled(application)
  }
}

1.1 初始化RefWatcher

RefWatcher的参数checkRetainedExecutor 和 onReferenceRetained

  • 在checkRetainedExecutor里, 会把任务mainHandler.postDelayed(it, LeakSentry.config.watchDurationMillis)默认延迟5秒执行.
  • onReferenceRetained = { listener.onReferenceRetained() }是Kotlin中的高阶函数, 这里的listener是 InternalLeakCanary ;

1.2 ActivityDestroyWatcher#install()

看名字很容易理解, 这是用来观测Activity.onDestroy()的,同理FragmentDestroyWatcher是观测Fragment.onDestroy()的,当然2.0还是保留了watch方法传入我们想要观测的类型.

内存泄露的定义就是超出了预期的生命周期没有被回收. 对于安卓来说, Activity和Fragment 因为都有明确的生命周期onCreate -> onDestroy, 可以视作最容易被观测的颗粒度.

1.2 LeakSentryListener#onLeakSentryInstalled(application)

这里是LeakSentry初始化结束的回调, 查看 LeakSentryListener 的实现类 InternalLeakCanary.

internal object InternalLeakCanary : leakcanary.internal.LeakSentryListener {
  override fun onLeakSentryInstalled(application: Application) {
    this.application = application
    // 创建HeapDumper
    val heapDumper = AndroidHeapDumper(application, leakDirectoryProvider)
    // 用于在通过RefrenceQueue判断内存泄露之前,手动触发一次GC 
    val gcTrigger = GcTrigger.Default
    //和LeakSentry一样, LeakCanary也支持配置
    val configProvider = { LeakCanary.config }
    //创建HandlerThread来执行耗时操作
    val handlerThread = HandlerThread(HeapDumpTrigger.LEAK_CANARY_THREAD_NAME)
    handlerThread.start()
    val backgroundHandler = Handler(handlerThread.looper)
    // HeadDump触发器
    heapDumpTrigger = HeapDumpTrigger(
        application, backgroundHandler, LeakSentry.refWatcher, gcTrigger, heapDumper, configProvider
    )
    //这里是kotlin的扩展方法, 下面会分析
    application.registerVisibilityListener { applicationVisible ->
      this.applicationVisible = applicationVisible
      heapDumpTrigger.onApplicationVisibilityChanged(applicationVisible)
    }
    addDynamicShortcut(application)
  }
}

在onLeakSentryInstalled()里做了以下操作:

  1. 初始化gcTrigger用来触发GC.
  2. 新建了一个HandlerThread用来异步处理headpDump.
  3. 初始化heapDumpTrigger. 用来生成heapDump文件.
  4. application.registerVisibilityListener()
    这里我们要看一下 application.registerVisibilityListener(), Application是没有这个方法的, 他使用了Kotlin的扩展函数
internal class VisibilityTracker(private val listener: (Boolean) -> Unit
) : ActivityLifecycleCallbacksAdapter() {

    private var startedActivityCount = 0

private var hasVisibleActivities: Boolean = false
  // 打开新页面, count++
  override fun onActivityStarted(activity: Activity) {
    startedActivityCount++
    if (!hasVisibleActivities && startedActivityCount == 1) {
      hasVisibleActivities = true
      listener.invoke(true)
    }
  }
  //页面stop, count--
  override fun onActivityStopped(activity: Activity) {
    if (startedActivityCount > 0) {
      startedActivityCount--
    }
    //startedActivityCount == 0, APP退到后台的情况.
    if (hasVisibleActivities && startedActivityCount == 0 && !activity.isChangingConfigurations) {
      hasVisibleActivities = false
      listener.invoke(false)
    }
  }
}

//Application扩展的方法在这
internal fun Application.registerVisibilityListener(listener: (Boolean) -> Unit) {
  //观测Activity生命周期
  registerActivityLifecycleCallbacks(VisibilityTracker(listener))
}

VisibilityTracker内重写了两个方法, onActivityStarted()和onActivityStopped(), 逻辑很简单, 页面onStart()时count++, onStop()时count--.
只有APP退到后台的情况, 满足条件调用listener.invoke(false).

回到

    application.registerVisibilityListener { applicationVisible ->
      this.applicationVisible = applicationVisible
      heapDumpTrigger.onApplicationVisibilityChanged(applicationVisible)
    }

heapDumpTrigger.onApplicationVisibilityChanged(applicationVisible)

  fun onApplicationVisibilityChanged(applicationVisible: Boolean) {
    if (applicationVisible) {
      applicationInvisibleAt = -1L
    } else {
      //App退到后台的情况
      applicationInvisibleAt = SystemClock.uptimeMillis()
      scheduleRetainedInstanceCheck("app became invisible", LeakSentry.config.watchDurationMillis)
    }
  }
  
  //backgroundHandler延迟5秒执行checkRetainedInstances()
  private fun scheduleRetainedInstanceCheck(
    reason: String,
    delayMillis: Long
  ) {
    backgroundHandler.postDelayed({
      //检查残留的实例, 下面会分析
      checkRetainedInstances(reason)
    }, delayMillis)
  }

总结一下, 在APP退到后台5秒后进行检查泄露的任务.

2、ActivityDestroyWatcher#install

伴生对象方法hinstall()里创建了ActivityDestroyWatcher,
调用application.registerActivityLifecycleCallbacks()来检测Activity的生命周期, 在自定义的 lifecycleCallbacks 的onActivityDestroyed()时调用refWatcher.watch(activity)来观察Activity的引用.

internal class ActivityDestroyWatcher private constructor(
  private val refWatcher: RefWatcher,
  private val configProvider: () -> Config
) {
  private val lifecycleCallbacks = object : ActivityLifecycleCallbacksAdapter() {
    //Activity onDestroy的回调
    override fun onActivityDestroyed(activity: Activity) {
      if (configProvider().watchActivities) {
        refWatcher.watch(activity)
      }
    }
  }

  companion object {
    fun install(
      application: Application,
      refWatcher: RefWatcher,
      configProvider: () -> Config
    ) {
      //Application注册检测Activity声明周期
      val activityDestroyWatcher = ActivityDestroyWatcher(refWatcher, configProvider)
      application.registerActivityLifecycleCallbacks(activityDestroyWatcher.lifecycleCallbacks)
    }
  }
}

3、RefWatcher.watch(activity)

RefWatcher在第一步已经完成了初始化, 开始看watch()代码之前先熟悉下RefWatcher的三个对象watchedReferences,retainedReferences,queue

  //等待被观察的对象, 还未被移动到retainedReferences列表
  private val watchedReferences = mutableMapOf()
 
  // 超出了预期的生命周期, 我们觉得可能会发生泄露的对象
  private val retainedReferences = mutableMapOf()

  // ReferenceQueue用于判断弱引用所持有的对象是否已被GC
  private val queue = ReferenceQueue()

开始看watch()代码

class RefWatcher {
  //watchedReference可以是Activity,Fragment,或者我们传入的任意对象
  @Synchronized fun watch(watchedReference: Any) {
    watch(watchedReference, "")
  }
 
  @Synchronized fun watch(
    watchedReference: Any,  
    referenceName: String
  ) {
    if (!isEnabled()) {
      return
    }
    //删除弱可达的引用
    removeWeaklyReachableReferences()
    //给每个watchedReference生成唯一的key
    val key = UUID.randomUUID().toString()
    val watchUptimeMillis = clock.uptimeMillis()
    //生成watchedReference的一个弱引用
    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(LinkedHashMap)
    watchedReferences[key] = reference
    //交给executor执行, 看第一步可以知道延迟5秒后执行
    checkRetainedExecutor.execute {
      moveToRetained(key) //移动到retainedReferences
    }
  }

  @Synchronized private fun moveToRetained(key: String) {
    removeWeaklyReachableReferences()
    //从watchedReferences中移除这个弱引用元素
    val retainedRef = watchedReferences.remove(key)
    //添加到 retainedReferences
    if (retainedRef != null) {
      retainedReferences[key] = retainedRef
      onReferenceRetained()
    }
  }
}
  1. 通过UUID生成这个被观测对象watchedReference(Activity,Fragment...)对应的key, 根据watchedReference创建弱引用KeyedWeakReference作为value ,加入LinkedHashMap watchedReferences中. 键值对
  2. 使用checkRetainedExecutor.execute { moveToRetained(key) }调度, 看第一步可以知道5秒后执行moveToRetained()任务
  3. 执行moveToRetained()任务, 从watchedReferences中移除这个元素,加入到另一个LinkedHashMapretainedReferences中. 然后调用LeakSentryListener.onReferenceRetained()

思考: 这里为什么要延迟5秒执行任务

我们都知道GC不是即时的, 页面销毁后预留5秒的时间给GC操作, 再后续分析引用泄露, 避免无效的分析.

4、LeakSentryListener.onReferenceRetained()

InternalLeakCanary实现了LeakSentryListener接口

internal object InternalLeakCanary : LeakSentryListener {
  
  override fun onReferenceRetained() {
    if (this::heapDumpTrigger.isInitialized) {
      heapDumpTrigger.onReferenceRetained()
    }
  }
}

HeapDumpTrigger#onReferenceRetained()里通过backgroundHandler.post把任务发送到HandlerThread中处理.

internal class HeapDumpTrigger{
  fun onReferenceRetained() {
    //上面提到的APP退到后台逻辑里,也会调用这个
    scheduleRetainedInstanceCheck("found new instance retained")
  }

  private fun scheduleRetainedInstanceCheck(reason: String) {
    //交给backgroundHandler发送到HandlerThread处理
    backgroundHandler.post {  
      checkRetainedInstances(reason)
    }
  }

  private fun checkRetainedInstances(reason: String) {
    CanaryLog.d("Checking retained instances because %s", reason)
    val config = configProvider()
    //如果LeakCanary.config的dumpHeap参数默认是true
    if (!config.dumpHeap) {
      return
    }
    //1.在GC之前, 筛选下retainedReferences中被回收掉的引用, 下面会说明
    var retainedKeys = refWatcher.retainedKeys
    //要检测的引用数量超过默认的数量, 就不处理了
    if (checkRetainedCount(retainedKeys, config.retainedVisibleThreshold)) return
    //如果程序在debug, 因为debug会保留之前的引用, 会对结果产生影响
    if (!config.dumpHeapWhenDebugging && DebuggerControl.isDebuggerAttached) {
      //这里等待20秒后再重试
      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
    }
    //2.手动触发GC
    gcTrigger.runGc()
    //3.在GC后, 再次筛选下retainedReferences中被回收掉的引用, 
    //到这一步剩下的就是没被回收掉的就是可能发生泄露的引用. 需要后续的dump分析
    retainedKeys = refWatcher.retainedKeys

    if (checkRetainedCount(retainedKeys, config.retainedVisibleThreshold)) return
    //4.保存这些没有被回收的对象的key, HeapAnalyzerService分析dump出的文件会用到
    HeapDumpMemoryStore.setRetainedKeysForHeapDump(retainedKeys)

    CanaryLog.d("Found %d retained references, dumping the heap", retainedKeys.size)
    HeapDumpMemoryStore.heapDumpUptimeMillis = SystemClock.uptimeMillis()
    dismissNotification()
    //5. 生成dump文件
    val heapDumpFile = heapDumper.dumpHeap()
    if (heapDumpFile == null) {
      //文件为空, 5秒后重试一次
      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
    }
    //dump成功, 从retainedReferences.keys中删除这些key
    refWatcher.removeRetainedKeys(retainedKeys)
    //6. 开启Service分析dumpFile结果
    HeapAnalyzerService.runAnalysis(application, heapDumpFile)
  }
}

可以看到, HeapDumpTrigger#onReferenceRetained()先调用了一次
refWatcher.retainedKeys, 然后调用gcTrigger.runGc()进行GC, 接着又调用了一次refWatcher.retainedKeys
简单理一下.

  1. 调用refWatcher.retainedKeys 得到残留的引用的key的集合retainedKeys
  2. 调用gcTrigger.runGc()进行GC
  3. 再次调用refWatcher.retainedKeys得到手动GC后残留的key的集合
  4. 到这一步retainedKeys就是可能发生泄露的引用了,通过HeapDumpMemoryStore保存retainedKeys, 留着后面和dump结果比对
  5. 通过heapDumper.dumpHeap()生成文件heapDumpFile
  6. 开启服务分析dump结果和retainedKeys来判断是否真正泄露HeapAnalyzerService.runAnalysis(application, heapDumpFile)

4.1 RefWatcher.retainedKeys

这一步是检查RefrenceQueue中是否出现了我们观察对象的弱引用, 如果出现了,说明被回收掉了, 那么就从 retainedReferences 删掉这个弱引用.
retainedReferences 最后剩下的是出现泄露需要dump的.

  val retainedKeys: Set
    @Synchronized get() {
      // 删除弱可达的引用
      removeWeaklyReachableReferences()
      //返回retainedReferences 剩下的keys的队列
      return HashSet(retainedReferences.keys)
    }

  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.
    var ref: KeyedWeakReference?
    // 已经回收掉的弱引用会存放在RefrenceQueue中,循环移除
    do {
      ref = queue.poll() as KeyedWeakReference?
      //如果RefrenceQueue里存在,说明这个弱引用被回收了
      if (ref != null) {
        val removedRef = watchedReferences.remove(ref.key)
        //如果watchedReferences中的这个弱引用被回收了,retainedReferences也移除掉这个弱引用
        if (removedRef == null) {
          retainedReferences.remove(ref.key)
        }
      }
    } while (ref != null)
  }

这里是用Refrence + RefrenceQueue判断对象是否被回收的
ReferenceQueue : 当检测到对象的可达性更改后, 将会把对象加入ReferenceQueue引用队列.
我们给每个被观测对象创建的KeyedWeakReference(watchedReference, key, referenceName, watchUptimeMillis, queue) 里, 就使用了Refrence + RefrenceQueue

class KeyedWeakReference(
  referent: Any,
  /**
   * Key used to find the retained references in the heap dump.
   */
  val key: String,
  val name: String,
  val watchUptimeMillis: Long,
  referenceQueue: ReferenceQueue
) : WeakReference(
    referent, referenceQueue
) {
  val className: String = referent.javaClass.name
}

当弱引用被回收后, 就会被加入我们构造他的时候关联的ReferenceQueue里,我们只要观测这个ReferenceQueue就能知道引用是否被回收了. LeakCanary就是这么干的. 更多原理可以参考带你读懂 Reference 和 ReferenceQueue

4.2 gcTrigger.runGc()

注释说‘system.gc()并不会每次都执行，参考AOSP中的的一段代码,使用Runtime.gc()更可能触发GC.

interface GcTrigger {

  fun runGc()

  object Default : GcTrigger {
    override fun 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 perform a gc.
      Runtime.getRuntime()
          .gc()
      enqueueReferences()
      System.runFinalization()
    }

    private fun enqueueReferences() {
      // Hack. We don't have a programmatic way to wait for the reference queue daemon to move
      // references to the appropriate queues.
      try {
        Thread.sleep(100)
      } catch (e: InterruptedException) {
        throw AssertionError()
      }
    }
  }
}

4.3 RefWatcher.retainedKeys再次调用

GC后, 继续遍历ReferenceQueue, 从retainedReferences中移除掉被回收掉的引用. 到这一步retainedReferences 剩下的就是可能发生泄露的引用了,需要dumpHeap来分析.

4.4 HeapDumper#dumpHeap()

AndroidHeapDumper是 HeapDumper 的实现类, 调用Debug.dumpHprofData(heapDumpFile.absolutePath) 生成了hprof文件. 和我们手动用AS profiler生成的一样

internal class AndroidHeapDumper(
  context: Context,
  private val leakDirectoryProvider: LeakDirectoryProvider
) : HeapDumper {

  override fun dumpHeap(): File? {
    val heapDumpFile = leakDirectoryProvider.newHeapDumpFile() ?: return null

    val waitingForToast = FutureResult()
    showToast(waitingForToast)
    //这里用countDownLatch来实现, 感兴趣的可以自行查看
    if (!waitingForToast.wait(5, SECONDS)) {
      CanaryLog.d("Did not dump heap, too much time waiting for Toast.")
      return null
    }
    //通知栏提示正在dumpHeap
    val notificationManager =
      context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
    if (Notifications.canShowNotification) {
      val dumpingHeap = context.getString(R.string.leak_canary_notification_dumping)
      val builder = Notification.Builder(context)
          .setContentTitle(dumpingHeap)
      val notification = Notifications.buildNotification(context, builder, LEAKCANARY_LOW)
      notificationManager.notify(R.id.leak_canary_notification_dumping_heap, notification)
    }

    val toast = waitingForToast.get()

    return try {
      //把 hprof 文件保存到 指定的path里
      Debug.dumpHprofData(heapDumpFile.absolutePath)
      if (heapDumpFile.length() == 0L) {
        CanaryLog.d("Dumped heap file is 0 byte length")
        null
      } else {
        heapDumpFile
      }
    } catch (e: Exception) {
      CanaryLog.d(e, "Could not dump heap")
      // Abort heap dump
      null
    } finally {
      cancelToast(toast)
      notificationManager.cancel(R.id.leak_canary_notification_dumping_heap)
    }
  }
}

5、HeapAnalyzerService.runAnalysis(application, heapDumpFile)

开启一个前台服务, 把上一步生成的heapDumpFile传进来分析

internal class HeapAnalyzerService : ForegroundService(

  fun runAnalysis(context: Context, heapDumpFile: File) {
      val intent = Intent(context, HeapAnalyzerService::class.java)
      intent.putExtra(HEAPDUMP_FILE_EXTRA, heapDumpFile)
      //这里使用前台服务配合Notification使用
      ContextCompat.startForegroundService(context, intent)
  }
}

HeapAnalyzerService是ForegroundService的子类, ForegroundService又是IntentSerice的子类, 这里的onHandleIntentInForeground 实际是在IntentService的onHandleIntent()中执行的

override fun onHandleIntent(intent: Intent?) {
  onHandleIntentInForeground(intent)
}

所以onHandleIntentInForeground是在子线程执行的.他主要做了两件事:

  1. val heapAnalysis = heapAnalyzer.checkForLeaks(heapDumpFile...) 分析上一步得到的heapDumpFile, 通过调用作者的另外一个库haha得到结果.
  2. config.analysisResultListener(application, heapAnalysis) 展示分析的结果.就是我们使用LeakCanary看到的泄露引用链的页面
override fun onHandleIntentInForeground(intent: Intent?) {
    if (intent == null) {
      CanaryLog.d("HeapAnalyzerService received a null intent, ignoring.")
      return
    }
    // Since we're running in the main process we should be careful not to impact it.
    //因为2.0不再和以前一样开启一个新的进程来处理, 这里手动降低线程的优先级
    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND)
    val heapDumpFile = intent.getSerializableExtra(HEAPDUMP_FILE_EXTRA) as File
    val heapAnalyzer = HeapAnalyzer(this)
    val config = LeakCanary.config
    //根据dump文件分析内存泄露的结果
    val heapAnalysis = heapAnalyzer.checkForLeaks(
          heapDumpFile, config.exclusionsFactory, config.computeRetainedHeapSize,
          config.leakInspectors, config.labelers
      )

    try {
      //检测结束回调 通知栏展示
      config.analysisResultListener(application, heapAnalysis)
    } finally {
      //finally中删除dump文件
      heapAnalysis.heapDumpFile.delete()
    }
  }

6、HeapAnalyzer#checkForLeaks

根据dump后的hprof文件查找泄露的情况.

class HeapAnalyzer constructor(
  private val listener: AnalyzerProgressListener
) {

  /**
   * Searches the heap dump for a [KeyedWeakReference] instance with the corresponding key,
   * and then computes the shortest strong reference path from that instance to the GC roots.
   */
  fun checkForLeaks(
    heapDumpFile: File,
    exclusionsFactory: ExclusionsFactory = { emptyList() },
    computeRetainedHeapSize: Boolean = false,
    reachabilityInspectors: List = emptyList(),
    labelers: List = emptyList()
  ): 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)
      )
    }

    listener.onProgressUpdate(READING_HEAP_DUMP_FILE)

    try {
      // 使用haha库创建一个HprofParser, 他实现了Closeable接口可以用kotlin的use函数
      HprofParser.open(heapDumpFile)
          .use { parser ->
            //扫描中..
            listener.onProgressUpdate(SCANNING_HEAP_DUMP)
            
            val (gcRootIds, keyedWeakReferenceInstances, cleaners) = scan(
                parser, computeRetainedHeapSize
            )
            val analysisResults = mutableMapOf()
            listener.onProgressUpdate(FINDING_WATCHED_REFERENCES)
            //从HeapDumpMemoryStore中读取dump之前存储的retainedKeys
            val (retainedKeys, heapDumpUptimeMillis) = readHeapDumpMemoryStore(parser)

            if (retainedKeys.isEmpty()) {
              val exception = IllegalStateException("No retained keys found in heap dump")
              return HeapAnalysisFailure(
                  heapDumpFile, System.currentTimeMillis(), since(analysisStartNanoTime),
                  HeapAnalysisException(exception)
              )
            }
            //找到泄露的引用
            val leakingWeakRefs =
              findLeakingReferences(
                  parser, retainedKeys, analysisResults, keyedWeakReferenceInstances,
                  heapDumpUptimeMillis
              )
            //找到泄露引用的最短路径
            val (pathResults, dominatedInstances) =
              findShortestPaths(
                  parser, exclusionsFactory, leakingWeakRefs, gcRootIds,
                  computeRetainedHeapSize
              )
            //计算泄露的大小
            val retainedSizes = if (computeRetainedHeapSize) {
              computeRetainedSizes(parser, pathResults, dominatedInstances, cleaners)
            } else {
              null
            }
            
            buildLeakTraces(
                reachabilityInspectors, labelers, pathResults, parser,
                leakingWeakRefs, analysisResults, retainedSizes
            )

            addRemainingInstancesWithNoPath(parser, leakingWeakRefs, analysisResults)

            return HeapAnalysisSuccess(
                heapDumpFile, System.currentTimeMillis(), since(analysisStartNanoTime),
                analysisResults.values.toList()
            )
          }
    } catch (exception: Throwable) {
      return HeapAnalysisFailure(
          heapDumpFile, System.currentTimeMillis(), since(analysisStartNanoTime),
          HeapAnalysisException(exception)
      )
    }
  }
}

7、LeakCanary.Config#analysisResultListener(application, heapAnalysis)

发送到notifycation,创建pendingIntent打开跳转到详细的泄露界面

object DefaultAnalysisResultListener : AnalysisResultListener {

   override fun invoke(application: Application,heapAnalysis: HeapAnalysis){
    val pendingIntent = LeakActivity.createPendingIntent(
        application, arrayListOf(GroupListScreen(), HeapAnalysisListScreen(), screenToShow)
    )

    val contentText = application.getString(R.string.leak_canary_notification_message)

    Notifications.showNotification(
        application, contentTitle, contentText, pendingIntent,
        R.id.leak_canary_notification_analysis_result,
        LEAKCANARY_RESULT
    )
  }
}

总结

  • LeakCanary通过监听页面的声明周期, 在Activity或Fragment执行onDestroy()时候调用refWatcher.watch()
  • 创建被观察对象的弱引用,加入watchedReferences, 预留5秒时间给GC再进行内存泄露的分析再检查内存的情况.
  • 在HandlerThread中进行分析, 通过RefrenceQueue判断引用是否被回收.手动触发GC, 再判断引用是否被回收. 到这一步retainedReferences中剩下的就是可能会发生泄露的引用.
  • 还是在HandlerThread中进行dump生成heapDumpFile, 开启一个前台服务去比对dump结果和retainedReferences.
  • 使用haha库比对分析, 得到真正泄露的实例, 计算最短引用路径, 展示结果.

你可能感兴趣的:(LeakCanary2.0源码解析)

  • YOLOv5 | 源码解析 | 计算损失loss原理——独家原创注释 kay_545 YOLOv8改进有效涨点Yolov5改进YOLOpython开发语言
    ⭐欢迎大家订阅我的专栏一起学习⭐订阅专栏，更新及时查看不迷路YOLOv5涨点专栏：http://t.csdnimg.cn/D9kR0YOLOv8涨点专栏：http://t.csdnimg.cn/5hNr8YOLOv7专栏：http://t.csdnimg.cn/hJsf1魔改网络、复现论文、优化创新各位订阅YOLOv8专栏读者，非常抱歉，这篇文章加错专栏了，但是因为是订阅的，所以不能删除或者移动这
  • SeaweedFS部署 仙女陈 linux
    SeaweedFS介绍SeaweedFS是一个分布式文件系统应用场景：主要用于存储处理小文件、大文件分块成小文件上传Githup地址：https://github.com/chrislusf/seaweedfs官方文档：https://github.com/chrislusf/seaweedfs/wikiseaweedfs源码解析：https://www.bbsmax.com/A/6pdDYXQK
  • 【axios】从源码解析axios拦截器是如何工作的 web安全学习资源库 前端javascriptvue.js
    本文所用axios版本号为：1.3.2。axios拦截器的配置方式axios中有两种拦截器：axios.interceptors.request.use(onFulfilled,onRejected,options)：配置请求拦截器。*onFulfilled方法在发送请求前执行，接收config对象，返回一个新的config对象，可在此方法内修改config对象。*onRejected方法在onF
  • 快速排序详解！c语言 自律的阿龙 数据结构c语言数据结构算法c语言排序算法
    目录快速排序是什么？快速排序的三种方法！快速排序的优化1.hore法（初代目）hore法的源码源码解析2.挖坑法（常用）！！！！挖坑法源码3.前后指针法（常用）前后指针代码4.非递归法快速排序全过程图快速排序是什么？快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法快速排序顾名思义，快速的排序，事实也如此，他的应用面广泛同时确实很快，因为他的时间复杂度是o（nlogn），相比前面的
  • 将Spring Cloud项目改造为Spring-cloud-kubernetes项目 公众号-芋道源码 中间件javalinux数据库springboot
    点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天10:33更新文章，每天掉亿点点头发...源码精品专栏原创|Java2021超神之路，很肝~中文详细注释的开源项目RPC框架Dubbo源码解析网络应用框架Netty源码解析消息中间件RocketMQ源码解析数据库中间件Sharding-JDBC和MyCAT源码解析作业调度中间件Elastic-Job源码解析分布式事务
  • ConcurrentHashMap的死循环问题 JWASX 源码分析哈希算法java散列表
    文章目录前言1.情景复现2.源码解析3.代码调试4.原因5.解决前言对于ConcurrentHashMap来说，能保证多线程下的安全问题，但是在JDK1.8中还是会出现一个bug，就是computeIfAbsent，下面就来详细说说死循环的原因1.情景复现首先就是bug的复现，首先了解下computeIfAbsent这个方法有什么用，其实方法第二个参数lambda表达式的意思就是如果找不到对应的k
  • Flink1.14源码解析Reactive-mode自动扩缩容 Better~Me 公开专栏大数据Flink内核源码解读flinkReactive-mode自动扩缩
    已付费购买专栏的朋友，请在申请查看权限时，备注你的CSDN名称才能通过查看权限，谢谢配合，谢谢理解。如未购买，请购买专栏，再申请。文章部分截图如下：更多详情请见以下链接：【腾讯文档】Flink源码中Reactive-Mode自动扩缩容关于扩容的处理
  • Redisson 如何实现分布式锁 不怕天黑_0819
    针对项目中使用的分布式锁进行简单的示例配置以及源码解析，并列举源码中使用到的一些基础知识点，但是没有对redisson中使用到的netty知识进行解析。本篇主要是对以下几个方面进行了探索Maven配置RedissonLock简单示例源码中使用到的Redis命令源码中使用到的lua脚本语义源码分析Maven配置org.redissonredisson2.2.12com.fasterxml.jacks
  • 若依前后端分离如何写移动端接口_前后端分离架构概述 weixin_39637661 若依前后端分离如何写移动端接口
    1、背景2、未分离时代（各种耦合）3、半分离时代4、分离时代5、总结参考《Java2019超神之路》《Dubbo实现原理与源码解析——精品合集》《Spring实现原理与源码解析——精品合集》《MyBatis实现原理与源码解析——精品合集》《SpringMVC实现原理与源码解析——精品合集》《SpringBoot实现原理与源码解析——精品合集》《数据库实体设计合集》《Java面试题——精品合集》《J
  • Android内存泄漏检测之LeakCanary2.0（Kotlin版）的实现原理 vivo互联网技术
    一、概述LeakCanary是一款非常常见的内存泄漏检测工具。经过一系列的变更升级，LeakCanary来到了2.0版本。2.0版本实现内存监控的基本原理和以往版本差异不大，比较重要的一点变化是2.0版本使用了自己的hprof文件解析器，不再依赖于HAHA，整个工具使用的语言也由Java切换到了Kotlin。本文结合源码对2.0版本的内存泄漏监控基本原理和hprof文件解析器实现原理做一个简单地分
  • 呵呵，一个 bug 你改了两天？难吗？ Java基基
    点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！源码精品专栏原创|Java2020超神之路，很肝~中文详细注释的开源项目RPC框架Dubbo源码解析网络应用框架Netty源码解析消息中间件RocketMQ源码解析数据库中间件Sharding-JDBC和MyCAT源码解析作业调度中间件Elastic-Job源码解析分布式事务中间件TCC-Transaction源码解析Eurek
  • 【Spring源码分析】解析配置类-ConfigurationClassPostProcessor源码分析 假正经的小柴 Java源码分析spring数据库前端
    阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spring的工具【Spring源码分析】BeanFactory系列接口解读【Spring源码分析】执行流程之非懒加载单例Bean的实例化逻辑【Spring源码分析】从源码角度去熟悉依赖注入（一）【Spring源码分析】从源码角度去熟悉依赖注入（二）【Spring源码分析】@Resource注入的源码解析【Spring源码分析
  • Slf4j 源码解析二-添加 slf4j-simple 日志实现框架 当当一丢丢
    主题本篇是Slf4j源码解析的第二篇，上篇介绍了无日志实现框架的执行流程本篇解析添加slf4j-simple日志实现框架的脉络已经知道：org/sfl4j/impl/StaticLoggerBinder.class是连接日志实现框架和Slf4jfacade的桥梁先浏览下slf4j-simple.jar的目录结构关键是探求如何与Slf4j-api.jarfacade关联的，实现框架项目的复杂简单no
  • Java集合篇之深入解析LinkedList 液态不合群 java开发语言
    写在开头作为ArrayList的同门师兄弟，LinkedList的师门地位逊色不少，除了在做算法题的时候我们会用到它之外，在实际的开发工作中我们极少使用它，就连它的创造者都说：“Iwroteit，andIneveruseit”，想想颇有点好笑，但这并不影响我们去学习它，个人认为它底层的链表逻辑对于我们代码思想的培养还是挺有帮助的。源码解析看过build哥文章的同学应该都知道，俺喜欢通过源码去学习和
  • Glide 源码解析 之 关键类简介 詹徐照
    Glide关键类介绍Glide单例，负责全局配置/***Asingletontopresentasimplestaticinterfaceforbuildingrequestswith*{@linkRequestBuilder}andmaintainingan{@linkEngine},{@linkBitmapPool},*{@linkcom.bumptech.glide.load.engine.
  • 类加载机制（2）类加载器源码解析 飞奔的口罩
    目录一、类加载器1、BootstrapClassLoader启动类加载器2、ExtensionClassLoader扩展类加载器3、ApplicationClassLoader应用类加载器4、CustomClassLoader自定义类加载器5、线程上下文类加载器二、java虚拟机入口应用：sun.misc.Launcher1、sun.misc.Launcher主入口2、内部类ExtClassLoa
  • 小游戏和GUI编程(7) | SimpleNN 界面源码解析 baiyu33 SFMLGUICNNMNISTLeNet手写数字识别
    小游戏和GUI编程(7)|SimpleNN界面源码解析0.简介SimpleNN是AdamYuan在高中一年级时用1天时间写出来的简易CNN,使用SFML做UI,用于交互式输入手写数字，这个数字被训练好的CNN网络执行推理得到识别结果,它的运行效果如下：这一篇我们来分析UI界面的代码,规划如下:完成本地构建(预计5分钟)确定和粗读UI代码(预计30分钟)拆解UI部件和自行重新实现(预计2小时)实际用
  • Spring AOP源码解析(二) anyoptional
    前言  上一篇中我们扒拉了一下spring-aop的底裤，详细解读了spring-aop中的各种抽象概念，本篇开始我们一起研究研究spring-aop的织入过程（基于5.2.6.RELEASE）。建议各位同学本地打开一份源码对照食用，效果更佳。  前方高能！！！本篇重度依赖于上一篇解读的抽象概念，不熟悉的同学请速速撤离，以免误伤。  正式开始之前，各位同学还请思考一下，在拥有了关于AOP的全局视角
  • Netty Review - ServerBootstrap源码解析 小小工匠 【Netty】ServerBootstrapNetty
    文章目录概述源码分析小结概述ServerBootstrapbootstrap=newServerBootstrap();bootstrap.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).option(ChannelOption.SO_BACKLOG,1024).childHandler(newChannelIn
  • 我给 Netty 提交了一个 bug 公众号：码海 内核unixepollhashtableuefi
    本系列Netty源码解析文章基于4.1.56.Final版本写在前面.....本文是笔者肉眼盯Bug系列的第三弹，前两弹分别是:抓到Netty一个Bug，顺带来透彻地聊一下Netty是如何高效接收网络连接的，在这篇文章中盯出了一个在Netty接收网络连接时，影响吞吐量的一个Bug。抓到Netty一个隐藏很深的内存泄露Bug|详解Recycler对象池的精妙设计与实现，在这篇文章中盯出了一个Nett
  • 11.我为 Netty 贡献源码 | 且看 Netty 如何应对 TCP 连接的正常关闭，异常关闭，半关闭场景 磊哥 低调 java
    我为Netty贡献源码|且看Netty如何应对TCP连接的正常关闭，异常关闭，半关闭场景本系列Netty源码解析文章基于4.1.56.Final版本写在前面.....本文是笔者肉眼盯Bug系列的第三弹，前两弹分别是:抓到Netty一个Bug，顺带来透彻地聊一下Netty是如何高效接收网络连接的，在这篇文章中盯出了一个在Netty接收网络连接时，影响吞吐量的一个Bug。抓到Netty一个隐藏很深的内
  • JDK源码阅读 0826 - 抽象集合 学习吧朱小宁
    我们经常在代码中使用到List、Set、Map,也粗略看过一些实现类的源码解析。现在去看下抽象类集合中的方法与具体实现类有哪些不同。publicabstractclassAbstractSetextendsAbstractCollectionimplementsSetpublicabstractclassAbstractListextendsAbstractCollectionimplements
  • spring源码解析流程，一步一步在源码加注释带你了解bean的加载过程 笨蛋CXJ springspringjava
    spring前述：spring源码环境搭建以及源码下载在文章后方有链接，可自行参考搭建，这里只是对加载过程做一个解析，spring全家桶远不止这些东东，感兴趣的小伙伴可以去官网看一下，本文将以源码加注释的方式进行过程解析，带你了解spring中bean到底是如何一步步加载完成了解重点：bean的生命周期、加载过程最终目的：学习spring源码短期内不对对你的技术有太大提升，可能只是了解到漂亮的代码
  • 京东平台研发：领域驱动设计（DDD）实践总结 公众号-芋道源码 tdd控制器360dbcp分布式
    点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天8:55更新文章，每天掉亿点点头发...源码精品专栏原创|Java2020超神之路，很肝~中文详细注释的开源项目RPC框架Dubbo源码解析网络应用框架Netty源码解析消息中间件RocketMQ源码解析数据库中间件Sharding-JDBC和MyCAT源码解析作业调度中间件Elastic-Job源码解析分布式事务中
  • ReentrantLock源码解析1-公平锁和非公平锁 LZhan
    1简言ReentrantLock：重入锁，是指一个线程获取锁之后再尝试获取锁时会自动获取锁。ReentrantLock实现了Lock接口，Lock接口定义的方法：//获取锁voidlock();//获取锁(可中断)voidlockInterruptibly()throwsInterruptedException;//尝试获取锁,如果没获取到锁,就返回falsebooleantryLock();//
  • LayoutInflater源码解析及常见相关报错分析 左大星 Android进阶androidandroidx
    在日常Android开发中，最经常使用的RecyclerView控件是大家都绕不开的，而编写其Adapter时更离不开LayoutInflater的调用。当然，如果你做这一行有些时日了，相信你对其使用一定是炉火纯青了。即使如此，我觉得LayoutInflater仍旧有值得分析的地方，相信你看完之后有更多的认识。Android系统中有许多包括ActivityManagerService在内的系统级服
  • Contractfuzzer 复现（2） 区区小块 区块链测试工具
    本文实现Contractfuzzer源码解析，在本地复现运行Contractfuzzer一、前期准备下载Contractfuzzer的源代码二、代码修改和部署Contractfuzzer的源代码分为三个部分，第一个是test，第二个是fuzzer，第三个私链1、testtest需要做的修改非常少，只需要安装babel模块，然后在package.json中插入"type":"module",就可以直
  • Netty Review - NioEventLoopGroup源码解析 小小工匠 【Netty】nioeventloopeventloopgroup
    文章目录概述类继承关系源码分析小结概述EventLoopGroupbossGroup=newNioEventLoopGroup(1);EventLoopGroupworkerGroup=newNioEventLoopGroup();这段代码是在使用Netty框架时常见的用法，用于创建两个不同的EventLoopGroup实例，一个用于处理连接请求（通常称为bossGroup），另一个用于处理连接后
  • 计算机哈希表相关知识 雁阵惊寒_zhn
    基础知识Java的HashMap源码解析(中高级Java工程师面试必备)Java8HashMap函数tableSizeFor详解JavaHashMap表的大小为什么必须是2的幂次Java8HashMap的迭代器和转化Set的实现哈希表相关算法面试题无重复字符的最长子串(LeetCode--3.无重复字符的最长子串)数组中找到两数之和为给定目标值(LeetCode--1.两数之和)
  • babe从入门到精通 vv_小虫虫
    前言前面我们写了几篇很长的文章去介绍babel源码、preset-env、runtime，babel源码解析一babel源码解析之（@babel/preset-env）babel源码解析之（@babel/plugin-transform-runtime）在babel配置中我们可能用过@babel/polyfill、core-js、core-js-pure、@babel/runtime、@babel
  • redis学习笔记——不仅仅是存取数据 Everyday都不同 returnSourceexpire/delincr/lpush数据库分区redis
    最近项目中用到比较多redis，感觉之前对它一直局限于get/set数据的层面。其实作为一个强大的NoSql数据库产品，如果好好利用它，会带来很多意想不到的效果。（因为我搞java，所以就从jedis的角度来补充一点东西吧。PS：不一定全，只是个人理解，不喜勿喷）   1、关于JedisPool.returnSource(Jedis jeids)   这个方法是从red
  • SQL性能优化-持续更新中。。。。。。 atongyeye oraclesql
    1 通过ROWID访问表--索引 你可以采用基于ROWID的访问方式情况,提高访问表的效率, , ROWID包含了表中记录的物理位置信息..ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系. 通常索引提供了快速访问ROWID的方法,因此那些基于索引列的查询就可以得到性能上的提高. 2 共享SQL语句--相同的sql放入缓存 3 选择最有效率的表
  • [JAVA语言]JAVA虚拟机对底层硬件的操控还不完善 comsci JAVA虚拟机
         如果我们用汇编语言编写一个直接读写CPU寄存器的代码段，然后利用这个代码段去控制被操作系统屏蔽的硬件资源，这对于JVM虚拟机显然是不合法的，对操作系统来讲，这样也是不合法的，但是如果是一个工程项目的确需要这样做，合同已经签了，我们又不能够这样做，怎么办呢？ 那么一个精通汇编语言的那种X客，是否在这个时候就会发生某种至关重要的作用呢？ &n
  • lvs- real 男人50 LVS
    #!/bin/bash # # Script to start LVS DR real server. # description: LVS DR real server # #.  /etc/rc.d/init.d/functions VIP=10.10.6.252 host='/bin/hostname' case "$1" in sta
  • 生成公钥和私钥 oloz DSA安全加密
    package com.msserver.core.util; import java.security.KeyPair; import java.security.PrivateKey; import java.security.PublicKey; import java.security.SecureRandom; public class SecurityUtil {
  • UIView 中加入的cocos2d，背景透明 374016526 cocos2dglClearColor
    要点是首先pixelFormat:kEAGLColorFormatRGBA8，必须有alpha层才能透明。然后view设置为透明glView.opaque = NO;[director setOpenGLView:glView];[self.viewController.view setBackgroundColor:[UIColor clearColor]];[self.viewControll
  • mysql常用命令 香水浓 mysql
    连接数据库 mysql -u troy -ptroy 备份表 mysqldump -u troy -ptroy mm_database mm_user_tbl > user.sql 恢复表（与恢复数据库命令相同） mysql -u troy -ptroy mm_database < user.sql 备份数据库 mysqldump -u troy -ptroy
  • 我的架构经验系列文章 - 后端架构 - 系统层面 agevs JavaScriptjquerycsshtml5
    系统层面： 高可用性 所谓高可用性也就是通过避免单独故障加上快速故障转移实现一旦某台物理服务器出现故障能实现故障快速恢复。一般来说，可以采用两种方式，如果可以做业务可以做负载均衡则通过负载均衡实现集群，然后针对每一台服务器进行监控，一旦发生故障则从集群中移除；如果业务只能有单点入口那么可以通过实现Standby机加上虚拟IP机制，实现Active机在出现故障之后虚拟IP转移到Standby的快速
  • 利用ant进行远程tomcat部署 aijuans tomcat
    在javaEE项目中，需要将工程部署到远程服务器上，如果部署的频率比较高，手动部署的方式就比较麻烦，可以利用Ant工具实现快捷的部署。这篇博文详细介绍了ant配置的步骤（http://www.cnblogs.com/GloriousOnion/archive/2012/12/18/2822817.html），但是在tomcat7以上不适用，需要修改配置，具体如下： 1.配置tomcat的用户角色
  • 获取复利总收入 baalwolf 获取
           public static void main(String args[]){         int money=200;         int year=1;         double rate=0.1; &
  • eclipse.ini解释 BigBird2012 eclipse
    大多数java开发者使用的都是eclipse，今天感兴趣去eclipse官网搜了一下eclipse.ini的配置，供大家参考，我会把关键的部分给大家用中文解释一下。还是推荐有问题不会直接搜谷歌，看官方文档，这样我们会知道问题的真面目是什么，对问题也有一个全面清晰的认识。 Overview 1、Eclipse.ini的作用 Eclipse startup is controlled by th
  • AngularJS实现分页功能 bijian1013 JavaScriptAngularJS分页
            对于大多数web应用来说显示项目列表是一种很常见的任务。通常情况下，我们的数据会比较多，无法很好地显示在单个页面中。在这种情况下，我们需要把数据以页的方式来展示，同时带有转到上一页和下一页的功能。既然在整个应用中这是一种很常见的需求，那么把这一功能抽象成一个通用的、可复用的分页（Paginator）服务是很有意义的。   &nbs
  • [Maven学习笔记三]Maven archetype bit1129 ArcheType
    archetype的英文意思是原型，Maven archetype表示创建Maven模块的模版，比如创建web项目，创建Spring项目等等.   mvn archetype提供了一种命令行交互式创建Maven项目或者模块的方式，   mvn archetype   1.在LearnMaven-ch03目录下，执行命令mvn archetype:gener
  • 【Java命令三】jps bit1129 Java命令
    jps很简单，用于显示当前运行的Java进程，也可以连接到远程服务器去查看   [hadoop@hadoop bin]$ jps -help usage: jps [-help] jps [-q] [-mlvV] [<hostid>] Definitions: <hostid>: <hostname>[:
  • ZABBIX2.2 2.4 等各版本之间的兼容性 ronin47
    zabbix更新很快，从2009年到现在已经更新多个版本，为了使用更多zabbix的新特性，随之而来的便是升级版本，zabbix版本兼容性是必须优先考虑的一点 客户端AGENT兼容 zabbix1.x到zabbix2.x的所有agent都兼容zabbix server2.4：如果你升级zabbix server，客户端是可以不做任何改变，除非你想使用agent的一些新特性。 Zabbix代理（p
  • unity 3d还是cocos2dx哪个适合游戏？ brotherlamp unity自学unity教程unity视频unity资料unity
    unity 3d还是cocos2dx哪个适合游戏？ 问：unity 3d还是cocos2dx哪个适合游戏？ 答：首先目前来看unity视频教程因为是3d引擎，目前对2d支持并不完善，unity 3d 目前做2d普遍两种思路，一种是正交相机，3d画面2d视角，另一种是通过一些插件，动态创建mesh来绘制图形单元目前用的较多的是2d toolkit，ex2d，smooth moves，sm2，
  • 百度笔试题：一个已经排序好的很大的数组，现在给它划分成m段，每段长度不定，段长最长为k，然后段内打乱顺序，请设计一个算法对其进行重新排序 bylijinnan java算法面试百度招聘
    import java.util.Arrays; /** * 最早是在陈利人老师的微博看到这道题： * #面试题#An array with n elements which is K most sorted，就是每个element的初始位置和它最终的排序后的位置的距离不超过常数K * 设计一个排序算法。It should be faster than O(n*lgn)。
  • 获取checkbox复选框的值 chiangfai checkbox
    <title>CheckBox</title> <script type = "text/javascript"> doGetVal: function doGetVal() { //var fruitName = document.getElementById("apple").value;//根据
  • MySQLdb用户指南 chenchao051 mysqldb
    原网页被墙，放这里备用。 MySQLdb User's Guide Contents Introduction Installation _mysql MySQL C API translation MySQL C API function mapping Some _mysql examples MySQLdb
  • HIVE 窗口及分析函数 daizj hive窗口函数分析函数
    窗口函数应用场景： （1）用于分区排序 （2）动态Group By （3）Top N （4）累计计算 （5）层次查询 一、分析函数 用于等级、百分点、n分片等。 函数             说明 RANK()     &nbs
  • PHP ZipArchive 实现压缩解压Zip文件 dcj3sjt126com PHPzip
    PHP ZipArchive 是PHP自带的扩展类，可以轻松实现ZIP文件的压缩和解压，使用前首先要确保PHP ZIP 扩展已经开启，具体开启方法就不说了，不同的平台开启PHP扩增的方法网上都有，如有疑问欢迎交流。这里整理一下常用的示例供参考。 一、解压缩zip文件 01 02 03 04 05 06 07 08 09 10 11
  • 精彩英语贺词 dcj3sjt126com 英语
    I'm always here              我会一直在这里支持你                &nb
  • 基于Java注解的Spring的IoC功能 e200702084 javaspringbeanIOCOffice
                                      
  • java模拟post请求 geeksun java
    一般API接收客户端（比如网页、APP或其他应用服务）的请求，但在测试时需要模拟来自外界的请求，经探索，使用HttpComponentshttpClient可模拟Post提交请求。 此处用HttpComponents的httpclient来完成使命。 import org.apache.http.HttpEntity ; import org.apache.http.HttpRespon
  • Swift语法之 ---- ?和!区别 hongtoushizi ?swift!
    转载自： http://blog.sina.com.cn/s/blog_71715bf80102ux3v.html   Swift语言使用var定义变量，但和别的语言不同，Swift里不会自动给变量赋初始值，也就是说变量不会有默认值，所以要求使用变量之前必须要对其初始化。如果在使用变量之前不进行初始化就会报错： var stringValue : String //
  • centos7安装jdk1.7 jisonami jdkcentos
    安装JDK1.7 步骤1、解压tar包在当前目录 [root@localhost usr]#tar -xzvf jdk-7u75-linux-x64.tar.gz 步骤2：配置环境变量 在etc/profile文件下添加 export JAVA_HOME=/usr/java/jdk1.7.0_75 export CLASSPATH=/usr/java/jdk1.7.0_75/lib
  • 数据源架构模式之数据映射器 home198979 PHP架构数据映射器datamapper
    前面分别介绍了数据源架构模式之表数据入口、数据源架构模式之行和数据入口数据源架构模式之活动记录，相较于这三种数据源架构模式，数据映射器显得更加“高大上”。   一、概念 数据映射器（Data Mapper）：在保持对象和数据库（以及映射器本身）彼此独立的情况下，在二者之间移动数据的一个映射器层。概念永远都是抽象的，简单的说，数据映射器就是一个负责将数据映射到对象的类数据。 &nb
  • 在Python中使用MYSQL pda158 mysqlpython
    缘由 　　近期在折腾一个小东西须要抓取网上的页面。然后进行解析。将结果放到 数据库中。 　　了解到 Python在这方面有优势，便选用之。 　　由于我有台 server上面安装有 mysql，自然使用之。在进行数据库的这个操作过程中遇到了不少问题，这里 记录一下，大家共勉。 　　 python中mysql的调用 　　 百度之后能够通过MySQLdb进行数据库操作。
  • 单例模式 hxl1988_0311 java单例设计模式单件
    package com.sosop.designpattern.singleton; /* * 单件模式：保证一个类必须只有一个实例，并提供全局的访问点 * * 所以单例模式必须有私有的构造器，没有私有构造器根本不用谈单件 * * 必须考虑到并发情况下创建了多个实例对象 * */ /** * 虽然有锁，但是只在第一次创建对象的时候加锁，并发时不会存在效率
  • 27种迹象显示你应该辞掉程序员的工作 vipshichg 工作
    1、你仍然在等待老板在2010年答应的要提拔你的暗示。 2、你的上级近10年没有开发过任何代码。 3、老板假装懂你说的这些技术，但实际上他完全不知道你在说什么。 4、你干完的项目6个月后才部署到现场服务器上。 5、时不时的，老板在检查你刚刚完成的工作时，要求按新想法重新开发。 6、而最终这个软件只有12个用户。 7、时间全浪费在办公室政治中，而不是用在开发好的软件上。 8、部署前5分钟才开始测试。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他