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源码解析)

  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Istio pilot-discovery服务发现源码解析（1.13版本） xidianjiapei001 #Istioistio云原生服务发现
    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
  • Java集合类框架源码分析 之 RoleList源码解析 【6】 yunzhonghefei Java集合类源码分析RoleList源码解析
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
  • VITS 源码解析2-模型概述 迪三 #NN_Audio音频人工智能
    VITs是文本到语音(Text-to-Speech,TTS)任务中最流行的技术之一，其实现思路是将文本语音信息融合到了HiFiGAN潜空间内,通过文本控制HiFiGAN的生成器，输出含文本语义的声音。VITs主要以GAN的方式训练,其生成器G是SynthesizerTrn，判别器D是MPD。VITS的判别器几乎和HiFiGAN一样，生成器则融合了文本、时序、声音三大类模型1.文件概述模型部分包含三
  • RBtree 努力的小带土 侯捷老师STLc++蓝桥杯
    终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！-【码炫课堂收费课节选之-红黑树源码解析及手写红黑树】_哔哩哔哩_bilibiliB站的听课记录，并写下如下红黑树c++版本代码，该课程真的史诗级推荐！/*RBtreeNode.h*****/#pragmaonceenum{RED=false,BLACK=true};templateclassRBtreeNode{public://红黑树的左右节点
  • 深入理解Kubernetes：kube-scheduler源码解析 mujingluo kubernetes容器云原生
    Kubernetes的调度器（kube-scheduler）是整个系统中至关重要的组件，它负责将待调度的Pods分配到合适的节点上。本文将深入分析kube-scheduler的源码，揭示其内部工作机制。kube-scheduler的核心功能kube-scheduler的核心功能包括：监听Pod变化：通过KubernetesAPI监听所有未调度的Pods。过滤（Filtering）：根据一系列规则（
  • 【Vesta发号器源码】PropertyMachineIdsProvider DeanChangDM
    Vesta发号器源码解析——PropertyMachineIdsProvider属性配置文件持有Id的模式,没啥东西，比单个的多了一个获取下一个的方法封装实现上略有一点点区别privatelong[]machineIds;privateintcurrentIndex;publiclonggetNextMachineId(){returngetMachineId();}publiclonggetMa
  • StarRocks分布式元数据源码解析 不甚了然 Iceberg知识集StarRocksIceberg数据湖湖仓一体大数据
    1.支持元数据表https://github.com/StarRocks/starrocks/pull/44276/files核心类：LogicalIcebergMetadataTable，Iceberg元数据表，将元数据的各个字段做成表的列，后期可以通过sql操作从元数据获取字段，这个表的组成字段是DataFile相关的字段public static LogicalIcebergMetadata
  • 【Starrocks】建表篇Fe源码解析 数算七弦 Starrocks大数据
    Starrocks系统架构简述现在市面上主流的OLAP存算一体架构主要有两类进程：Frontend（FE）和Backend（BE）Frontend一般是用Java写的。主要职责有：接收用户连接请求（MySQL协议层）元数据存储与管理查询语句的解析与查询计划的生成集群管控Backend一般是用C++写的，主要职责有：数据存储与管理查询计划的执行建表语句的执行过程与Mysql协议层交互词法解析语法解析
  • 智能农业设备软件工程师如何集成和管理农业物联网（IoT）平台 openwin_top 智能农业设备软件工程师物联网python开发语言深度学习大数据智能农业
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业物联网（IoT）平台涉及多个步骤，包括设备连接、数据收集、数据传输、数据存储、数据分析和展示。以下是详细分析和示例代码展示。1.设备连接和数据收集首先，智能农业设备需要能够与传感器和执
  • 智能农业设备软件工程师如何集成和管理农业设备的远程更新系统 openwin_top 智能农业设备软件工程师深度学习大数据物联网人工智能网络智能农业
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业设备的远程更新系统涉及多个技术层面，包括设备固件的安全更新、版本控制、网络通信，以及设备管理平台的开发。下面我们详细分析这些步骤，并提供一个基本的示例代码来展示如何实现这个系统。1.系
  • 智能农业设备软件工程师如何处理设备的远程诊断和修复 openwin_top 智能农业设备软件工程师网络智能农业物联网人工智能大数据深度学习
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位处理智能农业设备的远程诊断和修复涉及几个关键步骤，包括设备的数据采集、数据传输、远程诊断、远程控制和修复。以下是详细分析和示例代码：1.数据采集智能农业设备通常配备传感器和控制器，这些设备不断采集环
  • android10 按键音量调节源码解析 @OuYang android
    /frameworks/base/services/core/java/com/android/server/policy/PhoneWindowManager.javastaticIAudioServicegetAudioService(){IAudioServiceaudioService=IAudioService.Stub.asInterface(ServiceManager.checkS
  • android10 Settings源码解析 @OuYang android
    /packages/apps/Settings/AndroidManifest.xml.................................................................................activity-alias是Android里为了重复使用Activity而设计的。对于activity-alias标签，它有一个属性叫android:
  • MyBatis 源码解析：XMLScriptBuilder 工作机制 捕风捉你 MyBatis源码解读mybatisjava
    摘要MyBatis提供了强大的动态SQL功能，它通过解析XML配置文件中的动态SQL标签（如、、等），来实现灵活的SQL生成。而XMLScriptBuilder类则负责解析这些XML配置并生成最终的SQL语句。本文将详细解析XMLScriptBuilder的工作机制，并通过自定义实现来帮助您深入理解该类的功能。前言MyBatis中的动态SQL功能是通过解析XML配置文件实现的。XML文件中包含了动
  • c#视觉应用开发中如何使用Emgu CV在C#中进行图像处理？ openwin_top C#视觉应用开发问题系列c#图像处理开发语言
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位EmguCV是OpenCV的.NET包装器，可以让开发者在.NET语言（如C#）中使用OpenCV的功能进行图像处理。在进行图像处理时，EmguCV提供了丰富的API可以使用。以下是使用EmguCV
  • Elasticsearch——配置详解 smart哥 elasticsearch专题elasticsearch搜索引擎
    作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！阶段1、深入多线程阶段2、深入多线程设计模式阶段3、深入juc源码解析阶段4、深入jdk其余源码解析阶段5、深入jvm源码解析码哥源码部分码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场
  • Eventbus3.0源码解析 超威蓝猫l
    根据官方demo首先你需要先在activity中注册EventBus.getDefault().register(this);register所以我们先从getDefault方法开始看起/**Conveniencesingletonforappsusingaprocess-wideEventBusinstance.*/publicstaticEventBusgetDefault(){EventBu
  • 前端宝典之三：React源码解析之Fiber架构 桃子叔叔 大厂进阶前端深度解析系列react.js架构javascript
    本文主要内容：1、ReactConcurrent2、React15架构3、React16架构4、Fiber架构5、任务调度循环和fiber构造循环区别一、ReactConcurrentReact在解决CPU卡顿是会用到ReactConcurrent的概念，它是React中的一个重要特性和模块，主要的特点和原理如下一、主要特点和优势1、时间切片（TimeSlicing）允许将长时间运行的任务分割成小
  • Java集合之HashSet源码解析 气宇轩昂固执狂 JAVA面试笔试通关指南java开发语言HashSetHashSet源码
    一、HashSet概述：1、HashSet底层实现实际上就是利用HashMap的键（Key）来存储对象，原HashMap的键key的位置存放对象，值value的位置存放空的Object对象作为虚拟值；2、增加和删除都是直接调用HashMap的方法来实现的，没有修改和具体的查询方法，获取值只能通过iterator方法来迭代，迭代方法也是建立在HashMap的键的迭代方法上的。相关HashSet的操作
  • Spring之AOP底层源码解析（上） 阿立聊代码 spring代理模式
    动态代理代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。比如，现在存在一个UserService类：public class UserService  { public void test() {  System.out.println("test..."); }}此时，我们new一个UserService对象，然后执行test()方法，结果是
  • Spring Boot自动配置源码解析 一休哥助手 springbootjava数据库
    一、自动配置概述1.1什么是自动配置SpringBoot的自动配置是一种能够根据类路径中的依赖、配置文件中的属性以及其他条件，自动配置Spring应用上下文的功能。它通过扫描项目中的类和配置文件，判断哪些组件需要自动装配，从而减少了手动编写配置代码的繁琐过程。1.2自动配置的优点减少配置工作量：自动配置能够帮助开发者快速启动一个Spring应用，而不必担心各种复杂的XML或Java配置。智能化配置
  • Spring扩展点系列-InstantiationAwareBeanPostProcessor 码至终章 Spring生命周期扩展接口springsqljava扩展接口mavenspringboot
    文章目录简介测试一1、配置文件Bean注册2、单元测试方法3、测试类4、输出结果结论测试二1、测试类2、输出结果结论源码解析postProcessPropertiesCommonAnnotationBeanPostProcessorAnnotationInjectedBeanPostProcessor总结简介spring容器中Bean的生命周期内所有可扩展的点的调用顺序扩展接口实现接口Applic
  • MyBatis 源码解析：DefaultSqlSessionFactory 的创建与管理 捕风捉你 MyBatis源码解读mybatis
    摘要在MyBatis中，SqlSessionFactory是执行数据库操作的核心对象，它负责创建和管理SqlSession的生命周期。你是否想了解SqlSessionFactory的创建和管理过程？本文将通过自定义实现一个简化版的DefaultSqlSessionFactory，带你深入探讨MyBatis中DefaultSqlSessionFactory的创建与管理机制，并帮助你更好地掌握SqlS
  • FFmpeg源码解析系列（一）目录和编译 头快撑不住了 FFmpeg源码解析ffmpeg音视频视频编解码实时音视频图像处理
    引言当我们欣赏一部电影、观看一段视频或者享受一首音乐时，很少有人会停下来思考这一切是如何呈现在我们眼前的。然而，在每一帧的画面、每一秒的声音背后，有着一个不可思议的技术世界这个充满音视频的世界的核心之一，就是FFmpeg。FFmpeg是一个强大而复杂的多媒体处理工具，它为视频和音频编解码、流媒体传输、格式转换等提供了优秀的解决方案。在这个系列博客中，我们将深入探讨FFmpeg源码，解析它的工作原理
  • Spark MLlib LinearRegression线性回归算法源码解析 SmileySure Spark人工智能算法SparkMLlib
    线性回归一元线性回归hθ(x)=θ0+θ1xhθ(x)=θ0+θ1x——————–1多元线性回归hθ(x)=∑mi=1θixi=θTXhθ(x)=∑i=1mθixi=θTX—————–2损失函数J(θ)=1/2∑mi=1(hθ(xi)−yi)2J(θ)=1/2∑i=1m(hθ(xi)−yi)2—————31/2是为了求导时系数为1，平方里是真实值减去估计值我们的目的就是求其最小值最小二乘法要求较为
  • HashMap源码解析 dlwlrma ⥳ 兴趣类哈希算法散列表算法
    目录一:put方法流程二：get方法三：扩容机制一：put方法流程publicVput(Kkey,Vvalue){returnputVal(hash(key),key,value,false,true);}finalVputVal(inthash,Kkey,Vvalue,booleanonlyIfAbsent,booleanevict){Node[]tab;Nodep;intn,i;//判断数组是
  • Spring之启动过程源码解析 阿立聊代码 springspring数据库oracle
    前言分析通常，我们说的Spring启动，就是构造ApplicationContext对象以及调用refresh()方法的过程。首先，Spring启动过程主要做了这么几件事情：构造一个BeanFactory对象解析配置类，得到BeanDefinition，并注册到BeanFactory中解析@ComponentScan，此时就会完成扫描解析@Import解析@Bean...因为Application
  • 【HuggingFace Transformers】BertIntermediate 和 BertPooler源码解析 CS_木成河 HuggingFace深度学习人工智能bertpython大模型Transformer
    BertIntermediate和BertPooler源码解析1.介绍1.1位置与功能1.2相似点与不同点2.源码解析2.1BertIntermediate源码解析2.2BertPooler源码解析1.介绍1.1位置与功能(1)BertIntermediate位置：位于BertLayer的注意力层（BertSelfAttention）和输出层（BertOutput）之间。功能：它执行一个线性变换（
  • vue.js项目实战案例详细源码讲解 程序员小羊！ Javavue.js前端javascript
    大家好，我是程序员小羊！前言：为帮助大家更好地掌握Vue.js项目的开发流程，我将为你讲解一个完整的Vue.js实战案例，并提供详细的源码解析。这个案例将涵盖从项目创建到实现各种功能模块的全过程，适合用于构建一个具有基本CRUD功能的简单任务管理应用。案例介绍我们将开发一个任务管理应用（TaskManager），它允许用户添加、查看、编辑和删除任务。这个应用将包括以下主要功能模块：任务列表显示：展
  • 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其他