dboy_sl
dboy_sl

LeakCanary 原理详解

前言

本文是针对 LeakCanary Version 2.7 (2021-03-26) 版本的源码进行的分析。

debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.7'

1. 基础知识

  • java 引用之弱引用 WeakReference

弱引用， 当一个对象仅仅被weak reference（弱引用）指向, 而没有任何其他strong reference（强引用）指向的时候, 如果这时GC运行, 那么这个对象就会被回收，不论当前的内存空间是否足够，这个对象都会被回收。
构造方法:

  • public WeakReference(T referent)
  • public WeakReference(T referent, ReferenceQueue q)

主要说一下第二构造方法的第二个参数 ReferenceQueue。当WeakReference引用的对象referent被回收后，会把这个WeakReference或其子类的对象，放入队列ReferenceQueue中。敲黑板，LeakCanary 原理中的重要一环。

  • gc

gc 的可达性分析算法和引用计数法；
Java中可以作为GC Roots的对象：
1、虚拟机栈（javaStack）（栈帧中的局部变量区，也叫做局部变量表）中引用的对象。
2、方法区中的类静态属性引用的对象。
3、方法区中常量引用的对象。
4、本地方法栈中JNI(Native方法)引用的对象。

  • ContentProvider

ContentProvider初始化（onCreate）是在Application生命周期方法attachBaseContext之后、onCreate之前。

2. 源码分析

2.1 流程概述

为了脑中有个框架，便于理解。我将源码的分析过程分成三个步骤，接下来会依次按照这三个步骤去进行分析。图中涉及的类是调用的说明，不存在继承关系。


调用流程分析图.jpg
2.1.1 注册观察对象

注册流程就是LeakCanary的初始化过程，我们首先分析入口类 AppWatcherInstaller

  • AppWatcherInstaller
/**
 * Content providers are loaded before the application class is created. [AppWatcherInstaller] is
 * used to install [leakcanary.AppWatcher] on application start.
 */
internal sealed class AppWatcherInstaller : ContentProvider() {

  /**
   * [MainProcess] automatically sets up the LeakCanary code that runs in the main app process.
   */
  internal class MainProcess : AppWatcherInstaller()
···
  override fun onCreate(): Boolean {
    val application = context!!.applicationContext as Application
    AppWatcher.manualInstall(application)
    return true
  }
···

根据源码可知，AppWatcherInstaller是一个ContentProvider，它在app启动的时候就会自动调用onCreate中的代码。

AppWatcherInstaller 在 manifest 中注册源码如上。接着我们分析 onCreate 中的关键代码 AppWatcher.manualInstall(application)

  • AppWatcher
/**
 * The entry point API for using [ObjectWatcher] in an Android app. [AppWatcher.objectWatcher] is
 * in charge of detecting retained objects, and [AppWatcher] is auto configured on app start to
 * pass it activity and fragment instances. Call [ObjectWatcher.watch] on [objectWatcher] to
 * watch any other object that you expect to be unreachable.
 */
object AppWatcher {
···
/**
   * The [ObjectWatcher] used by AppWatcher to detect retained objects.
   * Only set when [isInstalled] is true.
   */
  val objectWatcher = ObjectWatcher(
    clock = { SystemClock.uptimeMillis() },
    checkRetainedExecutor = {
      check(isInstalled) {
        "AppWatcher not installed"
      }
      mainHandler.postDelayed(it, retainedDelayMillis)
    },
    isEnabled = { true }
  )
···
  @JvmOverloads
  fun manualInstall(
    application: Application,
    retainedDelayMillis: Long = TimeUnit.SECONDS.toMillis(5),
    watchersToInstall: List = appDefaultWatchers(application)
  ) {
    checkMainThread()
    if (isInstalled) {
      throw IllegalStateException(
        "AppWatcher already installed, see exception cause for prior install call", installCause
      )
    }
    check(retainedDelayMillis >= 0) {
      "retainedDelayMillis $retainedDelayMillis must be at least 0 ms"
    }
    installCause = RuntimeException("manualInstall() first called here")
    this.retainedDelayMillis = retainedDelayMillis
    if (application.isDebuggableBuild) {
      LogcatSharkLog.install()
    }
    // Requires AppWatcher.objectWatcher to be set
    LeakCanaryDelegate.loadLeakCanary(application)

    watchersToInstall.forEach {
      it.install()
    }
  }
   /**
   * Creates a new list of default app [InstallableWatcher], created with the passed in
   * [reachabilityWatcher] (which defaults to [objectWatcher]). Once installed,
   * these watchers will pass in to [reachabilityWatcher] objects that they expect to become
   * weakly reachable.
   *
   * The passed in [reachabilityWatcher] should probably delegate to [objectWatcher] but can
   * be used to filter out specific instances.
   */
  fun appDefaultWatchers(
    application: Application,
    reachabilityWatcher: ReachabilityWatcher = objectWatcher
  ): List {
    return listOf(
      ActivityWatcher(application, reachabilityWatcher),
      FragmentAndViewModelWatcher(application, reachabilityWatcher),
      RootViewWatcher(reachabilityWatcher),
      ServiceWatcher(reachabilityWatcher)
    )
  }
···
}

manualInstall 方法有三个参数，application 会在 AppWatcherInstaller 中传参， retainedDelayMillis 和watchersToInstall会走默认值。这里我们着重看下watchersToInstall 这个参数，这个参数的默认值是appDefaultWatchers方法返回的一个InstallableWatcher列表。列表中有ActivityWatcher、FragmentAndViewModelWatcher、RootViewWatcher和ServiceWatcher四个对象。四个对象构造方法都有一个公共参数reachabilityWatcher，用objectWatcher进行了赋值。这个列表在源码中遍历，并调用 item 的 install()方法。我们用ActivityWatcher 看看 install() 中干了什么。

/**
 * Expects activities to become weakly reachable soon after they receive the [Activity.onDestroy]
 * callback.
 */
class ActivityWatcher(
  private val application: Application,
  private val reachabilityWatcher: ReachabilityWatcher
) : InstallableWatcher {

  private val lifecycleCallbacks =
    object : Application.ActivityLifecycleCallbacks by noOpDelegate() {
      override fun onActivityDestroyed(activity: Activity) {
        reachabilityWatcher.expectWeaklyReachable(
          activity, "${activity::class.java.name} received Activity#onDestroy() callback"
        )
      }
    }

  override fun install() {
    application.registerActivityLifecycleCallbacks(lifecycleCallbacks)
  }

  override fun uninstall() {
    application.unregisterActivityLifecycleCallbacks(lifecycleCallbacks)
  }
}

ActivityWatcher.install() 注册了Activity 的生命周期回调，在 onActivityDestroyed 回调的时候调用了reachabilityWatcher.expectWeaklyReachable()方法。其实就是调用了AppWatcher中的objectWatcher对象方法。接着继续看ObjectWatcher

  • ObjectWatcher
class ObjectWatcher constructor(
  private val clock: Clock,
  private val checkRetainedExecutor: Executor,
  /**
   * Calls to [watch] will be ignored when [isEnabled] returns false
   */
  private val isEnabled: () -> Boolean = { true }
) : ReachabilityWatcher {

  private val onObjectRetainedListeners = mutableSetOf()

  /**
   * References passed to [watch].
   */
  private val watchedObjects = mutableMapOf()

  private val queue = ReferenceQueue()
···
  @Synchronized override fun expectWeaklyReachable(
    watchedObject: Any,
    description: String
  ) {
    if (!isEnabled()) {
      return
    }
    removeWeaklyReachableObjects()
    val key = UUID.randomUUID()
      .toString()
    val watchUptimeMillis = clock.uptimeMillis()
    val reference =
      KeyedWeakReference(watchedObject, key, description, watchUptimeMillis, queue)
    SharkLog.d {
      "Watching " +
        (if (watchedObject is Class<*>) watchedObject.toString() else "instance of ${watchedObject.javaClass.name}") +
        (if (description.isNotEmpty()) " ($description)" else "") +
        " with key $key"
    }

    watchedObjects[key] = reference
    checkRetainedExecutor.execute {
      moveToRetained(key)
    }
  }
···
  private fun removeWeaklyReachableObjects() {
    // WeakReferences are enqueued as soon as the object to which they point to becomes weakly
    // reachable. This is before finalization or garbage collection has actually happened.
    var ref: KeyedWeakReference?
    do {
      ref = queue.poll() as KeyedWeakReference?
      if (ref != null) {
        watchedObjects.remove(ref.key)
      }
    } while (ref != null)
  }
···
}

ObjectWatcher 中有两个成员变量，watchedObjects 和 queue 。根据上面对弱引用的了解，queue 存储的是已经回收引用对象的 reference。前面 activity的ondestory生命周期回调引发了expectWeaklyReachable 方法的调用，会首先走removeWeaklyReachableObjects方法，去移除watchedObjects 中已经被回收引用对象的reference，保证watchedObjects中的reference所引用的对象没有被回收。接着为当前 watchedObject 生成一个key 值，然后再放入watchedObjects中。objectWatcher是在AppWatcher中创建的，checkRetainedExecutor 是一个线程池，并通过mainHandler延时5秒执行了一个 runnable。这个runnable 执行会调用ObjectWatcher 的 moveToRetained方法。到这里先停一下，前面选了ActivityWatcher 源码梳理到这里，最终确定了LeakCanary 将已经执行了 onDestory生命周期的activity，通过 KeyedWeakReference 保存在了ObjectWatcher的watchedObjects这个map里。和ActivityWatcher一样，前面其他 三个watcher观测的对象按照一定的策略也会保存在这里。

到这里就梳理了LeakCanary的Watcher注册流程，ContentProvider的子类AppWatchInstaller是一切开始的地方。也分析了观察的可能泄漏的对象在一定的时机会被放在ObjectWatcher的watchedObjects中，比如前面的onActivityDestroyed 回调时机。ObjectWatcher是一个核心类，判断是否有内存泄漏，它是重要的一环。

2.1.2 触发内存检查

LeakCanary 中触发内存检查的时机可以分为两种：

  1. 观测对象可能要销毁的时机
    -- activity的onActivityDestroyed
    -- service的onServiceDestroyed
    -- rootview的onViewDetachedFromWindow
    -- fragment的onFragmentViewDestroyed
  2. 未熄屏的前提下，整个应用app对用户不可见的时候

怎么得出的这个结论，我们接着上一小节继续分析。前面我们分析到了ObjectWatcher的moveToRetained()方法被调用，往下看moveToRetained这个方法。

@Synchronized private fun moveToRetained(key: String) {
    removeWeaklyReachableObjects()
    val retainedRef = watchedObjects[key]
    // 判断应用对象是否被回收
    if (retainedRef != null) {
      retainedRef.retainedUptimeMillis = clock.uptimeMillis()
      // 没有回收，回调监听
      onObjectRetainedListeners.forEach { it.onObjectRetained() }
    }
  }

分析代码，最终回调了OnObjectRetainedListener监听，所以要看哪里添加了监听。添加监听的地方是 InternalLeakCanary 类的 invoke 方法中添加，代码如下

internal object InternalLeakCanary : (Application) -> Unit, OnObjectRetainedListener {

  private const val DYNAMIC_SHORTCUT_ID = "com.squareup.leakcanary.dynamic_shortcut"

  private lateinit var heapDumpTrigger: HeapDumpTrigger

···

  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.registerVisibilityListener { applicationVisible ->
      this.applicationVisible = applicationVisible
      heapDumpTrigger.onApplicationVisibilityChanged(applicationVisible)
    }
    registerResumedActivityListener(application)
    // 这里添加小鸟的快捷图标
    addDynamicShortcut(application)

    // We post so that the log happens after Application.onCreate()
    mainHandler.post {
      // https://github.com/square/leakcanary/issues/1981
      // We post to a background handler because HeapDumpControl.iCanHasHeap() checks a shared pref
      // which blocks until loaded and that creates a StrictMode violation.
      backgroundHandler.post {
        SharkLog.d {
          when (val iCanHasHeap = HeapDumpControl.iCanHasHeap()) {
            is Yup -> application.getString(R.string.leak_canary_heap_dump_enabled_text)
            is Nope -> application.getString(
              R.string.leak_canary_heap_dump_disabled_text, iCanHasHeap.reason()
            )
          }
        }
      }
    }
  }
···
override fun onObjectRetained() = scheduleRetainedObjectCheck()

  fun scheduleRetainedObjectCheck() {
    if (this::heapDumpTrigger.isInitialized) {
      heapDumpTrigger.scheduleRetainedObjectCheck()
    }
  }
···
}

分析代码，InternalLeakCanary 实现了 OnObjectRetainedListener ，它就是那个监听。找到重载方法onObjectRetained() ，往下看最终是调用了heapDumpTrigger.scheduleRetainedObjectCheck()。敲黑板，分析到这里得停一下，因为不知道是谁调用了invoke 方法，才添加了监听。看代码 InternalLeakCanary还是一个 Function1，参数为Application，返回值为Unit，所以它重载了invoke()。没有直接调用执行InternalLeakCanary.invoke的地方，那是在哪里调用的。其实在 AppWatcher. manualInstall() 分析的时候有一行代码，这行代码通过代理的方式执行了InternalLeakCanary 这个Function1。

LeakCanaryDelegate.loadLeakCanary(application)

internal object LeakCanaryDelegate {

  @Suppress("UNCHECKED_CAST")
  val loadLeakCanary by lazy {
    try {
      val leakCanaryListener = Class.forName("leakcanary.internal.InternalLeakCanary")
      leakCanaryListener.getDeclaredField("INSTANCE")
        .get(null) as (Application) -> Unit
    } catch (ignored: Throwable) {
      NoLeakCanary
    }
  }

  object NoLeakCanary : (Application) -> Unit, OnObjectRetainedListener {
    override fun invoke(application: Application) {
    }

    override fun onObjectRetained() {
    }
  }
}

invoke方法除了添加监听，还创建了HeapDumpTrigger对象；添加了一个 application.registerVisibilityListener 的一个回调，这个回调就是这一节最开始说的应用不可见引起内存检查的地方，一会儿再看这块的逻辑；invoke 中执行addDynamicShortcut添加了一个动态快捷方式，敲黑板，桌面上小鸟的由来。这些就是invoke做了的事。回到刚才的分析heapDumpTrigger.scheduleRetainedObjectCheck() ，看这个方法做了哪些事情。

internal class HeapDumpTrigger(
  private val application: Application,
  private val backgroundHandler: Handler,
  private val objectWatcher: ObjectWatcher,
  private val gcTrigger: GcTrigger,
  private val heapDumper: HeapDumper,
  private val configProvider: () -> Config
) {
  ···
  private fun checkRetainedObjects() {
    val iCanHasHeap = HeapDumpControl.iCanHasHeap()

    val config = configProvider()

    if (iCanHasHeap is Nope) {
      if (iCanHasHeap is NotifyingNope) {
        // Before notifying that we can't dump heap, let's check if we still have retained object.
        var retainedReferenceCount = objectWatcher.retainedObjectCount

        if (retainedReferenceCount > 0) {
          gcTrigger.runGc()
          retainedReferenceCount = objectWatcher.retainedObjectCount
        }

        val nopeReason = iCanHasHeap.reason()
        val wouldDump = !checkRetainedCount(
          retainedReferenceCount, config.retainedVisibleThreshold, nopeReason
        )

        if (wouldDump) {
          val uppercaseReason = nopeReason[0].toUpperCase() + nopeReason.substring(1)
          onRetainInstanceListener.onEvent(DumpingDisabled(uppercaseReason))
          showRetainedCountNotification(
            objectCount = retainedReferenceCount,
            contentText = uppercaseReason
          )
        }
      } else {
        SharkLog.d {
          application.getString(
            R.string.leak_canary_heap_dump_disabled_text, iCanHasHeap.reason()
          )
        }
      }
      return
    }

    var retainedReferenceCount = objectWatcher.retainedObjectCount

    if (retainedReferenceCount > 0) {
      gcTrigger.runGc()
      retainedReferenceCount = objectWatcher.retainedObjectCount
    }

    if (checkRetainedCount(retainedReferenceCount, config.retainedVisibleThreshold)) return

    val now = SystemClock.uptimeMillis()
    val elapsedSinceLastDumpMillis = now - lastHeapDumpUptimeMillis
    if (elapsedSinceLastDumpMillis < WAIT_BETWEEN_HEAP_DUMPS_MILLIS) {
      onRetainInstanceListener.onEvent(DumpHappenedRecently)
      showRetainedCountNotification(
        objectCount = retainedReferenceCount,
        contentText = application.getString(R.string.leak_canary_notification_retained_dump_wait)
      )
      scheduleRetainedObjectCheck(
        delayMillis = WAIT_BETWEEN_HEAP_DUMPS_MILLIS - elapsedSinceLastDumpMillis
      )
      return
    }

    dismissRetainedCountNotification()
    val visibility = if (applicationVisible) "visible" else "not visible"
    dumpHeap(
      retainedReferenceCount = retainedReferenceCount,
      retry = true,
      reason = "$retainedReferenceCount retained objects, app is $visibility"
    )
  }

  private fun dumpHeap(
    retainedReferenceCount: Int,
    retry: Boolean,
    reason: String
  ) {
    saveResourceIdNamesToMemory()
    val heapDumpUptimeMillis = SystemClock.uptimeMillis()
    KeyedWeakReference.heapDumpUptimeMillis = heapDumpUptimeMillis
    when (val heapDumpResult = heapDumper.dumpHeap()) {
      is NoHeapDump -> {
        if (retry) {
          SharkLog.d { "Failed to dump heap, will retry in $WAIT_AFTER_DUMP_FAILED_MILLIS ms" }
          scheduleRetainedObjectCheck(
            delayMillis = WAIT_AFTER_DUMP_FAILED_MILLIS
          )
        } else {
          SharkLog.d { "Failed to dump heap, will not automatically retry" }
        }
        showRetainedCountNotification(
          objectCount = retainedReferenceCount,
          contentText = application.getString(
            R.string.leak_canary_notification_retained_dump_failed
          )
        )
      }
      is HeapDump -> {
        lastDisplayedRetainedObjectCount = 0
        lastHeapDumpUptimeMillis = SystemClock.uptimeMillis()
        objectWatcher.clearObjectsWatchedBefore(heapDumpUptimeMillis)
        HeapAnalyzerService.runAnalysis(
          context = application,
          heapDumpFile = heapDumpResult.file,
          heapDumpDurationMillis = heapDumpResult.durationMillis,
          heapDumpReason = reason
        )
      }
    }
  }

  private fun saveResourceIdNamesToMemory() {
    val resources = application.resources
    AndroidResourceIdNames.saveToMemory(
      getResourceTypeName = { id ->
        try {
          resources.getResourceTypeName(id)
        } catch (e: NotFoundException) {
          null
        }
      },
      getResourceEntryName = { id ->
        try {
          resources.getResourceEntryName(id)
        } catch (e: NotFoundException) {
          null
        }
      })
  }

  fun onDumpHeapReceived(forceDump: Boolean) {
    backgroundHandler.post {
      dismissNoRetainedOnTapNotification()
      gcTrigger.runGc()
      val retainedReferenceCount = objectWatcher.retainedObjectCount
      if (!forceDump && retainedReferenceCount == 0) {
        SharkLog.d { "Ignoring user request to dump heap: no retained objects remaining after GC" }
        @Suppress("DEPRECATION")
        val builder = Notification.Builder(application)
          .setContentTitle(
            application.getString(R.string.leak_canary_notification_no_retained_object_title)
          )
          .setContentText(
            application.getString(
              R.string.leak_canary_notification_no_retained_object_content
            )
          )
          .setAutoCancel(true)
          .setContentIntent(NotificationReceiver.pendingIntent(application, CANCEL_NOTIFICATION))
        val notification =
          Notifications.buildNotification(application, builder, LEAKCANARY_LOW)
        notificationManager.notify(
          R.id.leak_canary_notification_no_retained_object_on_tap, notification
        )
        backgroundHandler.postDelayed(
          scheduleDismissNoRetainedOnTapNotification,
          DISMISS_NO_RETAINED_OBJECT_NOTIFICATION_MILLIS
        )
        lastDisplayedRetainedObjectCount = 0
        return@post
      }

      SharkLog.d { "Dumping the heap because user requested it" }
      dumpHeap(retainedReferenceCount, retry = false, "user request")
    }
  }

  private fun checkRetainedCount(
    retainedKeysCount: Int,
    retainedVisibleThreshold: Int,
    nopeReason: String? = null
  ): Boolean {
    val countChanged = lastDisplayedRetainedObjectCount != retainedKeysCount
    lastDisplayedRetainedObjectCount = retainedKeysCount
    //  没有泄漏的对象
    if (retainedKeysCount == 0) {
      if (countChanged) {
        SharkLog.d { "All retained objects have been garbage collected" }
        onRetainInstanceListener.onEvent(NoMoreObjects)
        showNoMoreRetainedObjectNotification()
      }
      return true
    }

    val applicationVisible = applicationVisible
    val applicationInvisibleLessThanWatchPeriod = applicationInvisibleLessThanWatchPeriod

    if (countChanged) {
      val whatsNext = if (applicationVisible) {
        if (retainedKeysCount < retainedVisibleThreshold) {
          "not dumping heap yet (app is visible & < $retainedVisibleThreshold threshold)"
        } else {
          if (nopeReason != null) {
            "would dump heap now (app is visible & >=$retainedVisibleThreshold threshold) but $nopeReason"
          } else {
            "dumping heap now (app is visible & >=$retainedVisibleThreshold threshold)"
          }
        }
      } else if (applicationInvisibleLessThanWatchPeriod) {
        val wait =
          AppWatcher.config.watchDurationMillis - (SystemClock.uptimeMillis() - applicationInvisibleAt)
        if (nopeReason != null) {
          "would dump heap in $wait ms (app just became invisible) but $nopeReason"
        } else {
          "dumping heap in $wait ms (app just became invisible)"
        }
      } else {
        if (nopeReason != null) {
          "would dump heap now (app is invisible) but $nopeReason"
        } else {
          "dumping heap now (app is invisible)"
        }
      }

      SharkLog.d {
        val s = if (retainedKeysCount > 1) "s" else ""
        "Found $retainedKeysCount object$s retained, $whatsNext"
      }
    }
      // 内存显露的watchObject 少于5个，会先显示一个通知暂不走堆栈分析，等待2秒再走一次判断
    if (retainedKeysCount < retainedVisibleThreshold) {
      if (applicationVisible || applicationInvisibleLessThanWatchPeriod) {
        if (countChanged) {
          onRetainInstanceListener.onEvent(BelowThreshold(retainedKeysCount))
        }
        showRetainedCountNotification(
          objectCount = retainedKeysCount,
          contentText = application.getString(
            R.string.leak_canary_notification_retained_visible, retainedVisibleThreshold
          )
        )
        scheduleRetainedObjectCheck(
          delayMillis = WAIT_FOR_OBJECT_THRESHOLD_MILLIS
        )
        return true
      }
    }
    return false
  }

  fun scheduleRetainedObjectCheck(
    delayMillis: Long = 0L
  ) {
    val checkCurrentlyScheduledAt = checkScheduledAt
    if (checkCurrentlyScheduledAt > 0) {
      //  前一次 checkRetainedObjects 还没执行
      return
    }
    checkScheduledAt = SystemClock.uptimeMillis() + delayMillis
    backgroundHandler.postDelayed({
      checkScheduledAt = 0
      checkRetainedObjects()
    }, delayMillis)
  }
···
}

scheduleRetainedObjectCheck 会走到 checkRetainedCount 方法，该方法中会通过objectWatcher.retainedObjectCount 去判断是否有可能泄露的对象。count > 0 则会通过 gcTrigger.runGc() 进行一次 gc操作，然后再获取count进行判断，如果count仍然>0则调用dumpHeap 方法进行堆栈信息分析，调用到 HeapAnalyzerService.runAnalysis()方法。到这里就是判定已经有内存泄漏，往下就是对堆栈进行分析了。关于触发内存检查的时机，上面我们已经分析完了观测对象可能要销毁的时机中的activity的onActivityDestroyed，因为我们是选取ActivityWatcher 进行了分析，其他三种就不在这里分析赘述了。
那再看看第二种时机，未锁屏的前提下，整个应用app对用户不可见的时候。上面其实已经分析到了，在InternalLeakCanary的invoke方法添加了applicationVisible的回调。

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

看下registerVisibilityListener这个拓展方法

internal fun Application.registerVisibilityListener(listener: (Boolean) -> Unit) {
  val visibilityTracker = VisibilityTracker(listener)
  registerActivityLifecycleCallbacks(visibilityTracker)
  registerReceiver(visibilityTracker, IntentFilter().apply {
    addAction(ACTION_SCREEN_ON)
    addAction(ACTION_SCREEN_OFF)
  })
}

可见性这块逻辑就是通过注册广播接收者接收系统屏幕息屏与否的广播，注册ActivityLifecycle 来判断当前是否有用户可见的activity。这块逻辑是在VisibilityTracker 中处理的，可见性变化就会调用InternalLeakCanary的invoke中的可见性回调，接着就会调用 heapDumpTrigger.onApplicationVisibilityChanged(applicationVisible)，进入这个方法

 /**
   ** 未锁屏的前提下，整个应用app对用户不可见的时候引发内存检查
   **/
  fun onApplicationVisibilityChanged(applicationVisible: Boolean) {
    if (applicationVisible) {
      applicationInvisibleAt = -1L
    } else {
      applicationInvisibleAt = SystemClock.uptimeMillis()
      // Scheduling for after watchDuration so that any destroyed activity has time to become
      // watch and be part of this analysis.
      scheduleRetainedObjectCheck(
        delayMillis = AppWatcher.config.watchDurationMillis
      )
    }
  }

分析可知当 applicationVisible 为false 的时候，也就是不可见的时候，回调用到scheduleRetainedObjectCheck -> checkRetainedObjects -> dumpHeap ->HeapAnalyzerService.runAnalysis() 。应用可见性这个时机也就走到堆栈分析这一步了。

2.1.3 分析内存堆栈

上一小节分析到 HeapAnalyzerService.runAnalysis()

fun runAnalysis(
      context: Context,
      heapDumpFile: File,
      heapDumpDurationMillis: Long? = null,
      heapDumpReason: String = "Unknown"
    )

该方法有个 heapDumpFile 参数，这个参数就是进行堆栈分析的文件。这个文件怎么来的，追溯参数对象创建的地方，是 AndroidHeapDumper.dumpHeap()方法。文件的创建以及数据的写入就是通过下面一段代码

override fun dumpHeap(): DumpHeapResult {
    // 创建空文件
    val heapDumpFile = leakDirectoryProvider.newHeapDumpFile() ?: return NoHeapDump
    ···
    return try {
      val durationMillis = measureDurationMillis {
        // 将 dump hprof 数据写入到空文件中
        Debug.dumpHprofData(heapDumpFile.absolutePath)
      }
      if (heapDumpFile.length() == 0L) {
        SharkLog.d { "Dumped heap file is 0 byte length" }
        NoHeapDump
      } else {
        HeapDump(file = heapDumpFile, durationMillis = durationMillis)
      }
    } catch (e: Exception) {
      SharkLog.d(e) { "Could not dump heap" }
      // Abort heap dump
      NoHeapDump
    } finally {
      cancelToast(toast)
      notificationManager.cancel(R.id.leak_canary_notification_dumping_heap)
    }
  }

看源码可知，要分析的堆栈信息是通过android sdk 中的 Debug.dumpHprofData()方法来获取堆栈信息的。有文件之后，接着看HeapAnalyzerService.runAnalysis() 的实现

internal class HeapAnalyzerService : ForegroundService(
  HeapAnalyzerService::class.java.simpleName,
  R.string.leak_canary_notification_analysing,
  R.id.leak_canary_notification_analyzing_heap
), OnAnalysisProgressListener {

  override fun onHandleIntentInForeground(intent: Intent?) {
    if (intent == null || !intent.hasExtra(HEAPDUMP_FILE_EXTRA)) {
      SharkLog.d { "HeapAnalyzerService received a null or empty intent, ignoring." }
      return
    }

    // Since we're running in the main process we should be careful not to impact it.
    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND)
    val heapDumpFile = intent.getSerializableExtra(HEAPDUMP_FILE_EXTRA) as File
    val heapDumpReason = intent.getStringExtra(HEAPDUMP_REASON_EXTRA)
    val heapDumpDurationMillis = intent.getLongExtra(HEAPDUMP_DURATION_MILLIS_EXTRA, -1)

    val config = LeakCanary.config
    // 分析堆栈，拿到分析结果
    val heapAnalysis = if (heapDumpFile.exists()) {
      analyzeHeap(heapDumpFile, config)
    } else {
      missingFileFailure(heapDumpFile)
    }
    val fullHeapAnalysis = when (heapAnalysis) {
      is HeapAnalysisSuccess -> heapAnalysis.copy(
        dumpDurationMillis = heapDumpDurationMillis,
        metadata = heapAnalysis.metadata + ("Heap dump reason" to heapDumpReason)
      )
      is HeapAnalysisFailure -> heapAnalysis.copy(dumpDurationMillis = heapDumpDurationMillis)
    }
    onAnalysisProgress(REPORTING_HEAP_ANALYSIS)
    // 将分析结果回调
    config.onHeapAnalyzedListener.onHeapAnalyzed(fullHeapAnalysis)
  }
···
  companion object {
    private const val HEAPDUMP_FILE_EXTRA = "HEAPDUMP_FILE_EXTRA"
    private const val HEAPDUMP_DURATION_MILLIS_EXTRA = "HEAPDUMP_DURATION_MILLIS_EXTRA"
    private const val HEAPDUMP_REASON_EXTRA = "HEAPDUMP_REASON_EXTRA"
    private const val PROGUARD_MAPPING_FILE_NAME = "leakCanaryObfuscationMapping.txt"

    fun runAnalysis(
      context: Context,
      heapDumpFile: File,
      heapDumpDurationMillis: Long? = null,
      heapDumpReason: String = "Unknown"
    ) {
      val intent = Intent(context, HeapAnalyzerService::class.java)
      intent.putExtra(HEAPDUMP_FILE_EXTRA, heapDumpFile)
      intent.putExtra(HEAPDUMP_REASON_EXTRA, heapDumpReason)
      heapDumpDurationMillis?.let {
        intent.putExtra(HEAPDUMP_DURATION_MILLIS_EXTRA, heapDumpDurationMillis)
      }
      startForegroundService(context, intent)
    }

    private fun startForegroundService(
      context: Context,
      intent: Intent
    ) {
      if (SDK_INT >= 26) {
        context.startForegroundService(intent)
      } else {
        // Pre-O behavior.
        context.startService(intent)
      }
    }
  }
}

代码中开启了HeapAnalyzerService这个前台服务，服务开启会调用 onHandleIntentInForeground 中的逻辑。onHandleIntentInForeground会调用 analyzeHeap 拿到分析结果，然后将分析结果通过config.onHeapAnalyzedListener.onHeapAnalyzed(fullHeapAnalysis)进行回调给DefaultOnHeapAnalyzedListener的onHeapAnalyzed方法

  override fun onHeapAnalyzed(heapAnalysis: HeapAnalysis) {
    SharkLog.d { "\u200B\n${LeakTraceWrapper.wrap(heapAnalysis.toString(), 120)}" }
    // 将分析结果存入数据库，用于在activity中查看
    val db = LeaksDbHelper(application).writableDatabase
    val id = HeapAnalysisTable.insert(db, heapAnalysis)
    db.releaseReference()

    val (contentTitle, screenToShow) = when (heapAnalysis) {
      is HeapAnalysisFailure -> application.getString(
        R.string.leak_canary_analysis_failed
      ) to HeapAnalysisFailureScreen(id)
      is HeapAnalysisSuccess -> {
        val retainedObjectCount = heapAnalysis.allLeaks.sumBy { it.leakTraces.size }
        val leakTypeCount = heapAnalysis.applicationLeaks.size + heapAnalysis.libraryLeaks.size
        application.getString(
          R.string.leak_canary_analysis_success_notification, retainedObjectCount, leakTypeCount
        ) to HeapDumpScreen(id)
      }
    }

    if (InternalLeakCanary.formFactor == TV) {
      showToast(heapAnalysis)
      printIntentInfo()
    } else {
      // 显示通知信息
      showNotification(screenToShow, contentTitle)
    }
  }
  private fun showNotification(
    screenToShow: Screen,
    contentTitle: String
  ) {
    val pendingIntent = LeakActivity.createPendingIntent(
      application, arrayListOf(HeapDumpsScreen(), 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_MAX
    )
  }

该回调中将分析结果存入数据库，展示一条通知，点击通知回调转到pendingIntent 的目标页面 LeakActivity 展示数据库中的信息。关于如何得到分析hprof文件结果的，其实就是 HeapAnalyzerService 的 analyzeHeap() 方法返回值，一直查看调用，实质调用的是 FindLeakInput 的 analyzeGraph 拓展方法

private fun FindLeakInput.analyzeGraph(
    metadataExtractor: MetadataExtractor,
    leakingObjectFinder: LeakingObjectFinder,
    heapDumpFile: File,
    analysisStartNanoTime: Long
  ): HeapAnalysisSuccess {
    listener.onAnalysisProgress(EXTRACTING_METADATA)
    val metadata = metadataExtractor.extractMetadata(graph)

    val retainedClearedWeakRefCount = KeyedWeakReferenceFinder.findKeyedWeakReferences(graph)
      .filter { it.isRetained && !it.hasReferent }.count()

    // This should rarely happens, as we generally remove all cleared weak refs right before a heap
    // dump.
    val metadataWithCount = if (retainedClearedWeakRefCount > 0) {
      metadata + ("Count of retained yet cleared" to "$retainedClearedWeakRefCount KeyedWeakReference instances")
    } else {
      metadata
    }

    listener.onAnalysisProgress(FINDING_RETAINED_OBJECTS)
    // 查找到泄露对象id
    val leakingObjectIds = leakingObjectFinder.findLeakingObjectIds(graph)
    // 查找泄露对象并分成应用泄露、库泄露和其他泄露
    val (applicationLeaks, libraryLeaks, unreachableObjects) = findLeaks(leakingObjectIds)

    return HeapAnalysisSuccess(
      heapDumpFile = heapDumpFile,
      createdAtTimeMillis = System.currentTimeMillis(),
      analysisDurationMillis = since(analysisStartNanoTime),
      metadata = metadataWithCount,
      applicationLeaks = applicationLeaks,
      libraryLeaks = libraryLeaks,
      unreachableObjects = unreachableObjects
    )
  }

到这里就把LeakCanary核心流程梳理结束了，了解了LeakCanary 是如何检测内存泄漏、提示以及展示的。

LeakCanary 主页
LeakCanary GitHub
关于Java中的WeakReference

你可能感兴趣的:(LeakCanary 原理详解)

  • 数据结构奇妙旅程之深入解析快速排序 山间漫步人生路 数据结构排序算法算法
    快速排序（QuickSort）是一种高效的排序算法，它使用了分治法的策略来将一个数组排序。其基本思想是选择一个基准元素，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比基准元素小，另一部分的所有数据都比基准元素大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。工作原理选择基准：从待排序的序列中选一个元素作为基准（pivo
  • Flink中的SQL Client和SQL Gateway BigDataMLApplication flinkflinksqlgateway
    Flink中的SQLClient和SQLGateway对比目录定义基本原理适用场景主要区别常用运维命令示例官方链接正文1.定义SQLClient：FlinkSQLClient是一种用于提交和执行FlinkSQL语句的命令行界面或图形界面工具。SQLGateway：FlinkSQLGateway是一个独立的服务，它允许客户端通过RESTfulAPI将SQL查询提交到Flink集群。2.基本原理SQL
  • 以前开发MFC界面如何快速转成QT界面 广州视觉芯软件有限公司 mfcqtc++
    将MFC界面快速转换为Qt界面可能需要进行一些手动工作，因为MFC和Qt是两个不同的界面框架，它们具有不同的设计和实现原理。但是，以下步骤可以帮助你快速进行转换：创建一个新的Qt项目：使用QtCreator创建一个新的Qt项目。分析MFC界面：仔细分析你的MFC界面，包括窗口、对话框、控件等的布局、样式和行为。重新设计界面：使用Qt的可视化设计器重新设计界面。在QtCreator的设计器中，你可以
  • 【计算机网络】第 3 问：电路交换、报文交换、分组交换之间的区别？ 孤独打铁匠Julian #计算机408考研面试计算机网络计算机网络网络
    电路交换、报文交换、分组交换之间的区别？省流图详解电路交换电路交换的优点电路交换的缺点建立连接时间长的原因报文交换报文交换的优点报文交换的缺点分组交换分组交换的优点分组交换的缺点比较总结省流图详解电路交换在进行数据传输前，两个结点之间必须先建立一条专用（双方独占）的物理通信路径（由通信双方之间的交换设备和链路逐段连接而成），该路径可能经过许多中间结点。这一路径在整个数据传输期间一直被独占，直到通信
  • C#WPF控件TextBlock详解 未来无限 C#WPF程序设计c#wpf控件TextBlock回车换行多行显示强制回车换行
    本文讲解WPF控件TextBlock。目录定义常用属性实例如何实现自动换行？如何强制回车换行？
  • C#WPF窗口类 Window详解 未来无限 C#WPF程序设计c#wpfwindow类详解
    本文详解C#WPF窗口类Window。目录定义Window窗体属性Window窗体事件实例演示定义WPF中的Window继承于ContentControl，内部可以承载一个Content，当然，借助于ItemsControl或Panel，Content也可以向下添加多个
  • 谷歌浏览器驱动Chromedriver（114-120版本）文件以及驱动下载教程 pigerr杨 Pythonpythonchromedrivers
    ChromeDriver官方网站GitHub||GoogleChromeLabs/chrome-for-testingChromeDriver113-125_JSONChromeforTestingavailability123-125zip白月黑羽Python基础|进阶|Qt图形界面|Django|自动化测试|性能测试|JS语言|JS前端|原理与安装
  • 安卓笔记本 - Handler Message MessageQueue Looper SocialException
    不爱写字，一张图解决。Handler,Message,MessageQueue,Looper工作原理
  • 自动化测试 —— Pytest fixture及conftest详解 咖啡加剁椒③ 软件测试pytest功能测试软件测试自动化测试程序人生职场和发展
    前言fixture是在测试函数运行前后，由pytest执行的外壳函数。fixture中的代码可以定制，满足多变的测试需求，包括定义传入测试中的数据集、配置测试前系统的初始状态、为批量测试提供数据源等等。fixture是pytest的精髓所在，类似unittest中setup/teardown，但是比它们要强大、灵活很多，它的优势是可以跨文件共享。一、Pytestfixture1.pytestfix
  • Vue 常见面试题(一) 安生生申 面试题vue.js前端javascript
    目录1、Vue的最大的优势是什么？（必会）2、Vue和jQuery两者之间的区别是什么？（必会）3、MVVM和MVC区别是什么？哪些场景适合？（必会）1、基本定义2、使用场景3、两者之间的区别4、Vue数据双向绑定的原理是什么?（必会）5、Object.defineProperty和Proxy的区别（必会）6、Vue生命周期总共分为几个阶段？（必会）7、第一次加载页面会触发哪几个钩子函数？（必会）
  • 以客户为中心的企业设计（咨询执业笔记） 觉者看世界
    以客户为中心的企业设计（咨询执业笔记）——何伏全案咨询知名专家数字经济大行其道，过剩的风险资本自由流动，股权市场日益强势，这些力量综合在一起，产生出诸多不合理的企业设计。这些事实使得企业设计的再创造越来越需要一种约束力，许多公司和投资者未能熟谙这种约束力，或者未能将其基本原理运用于具体的商业行为中，因此付出了沉重的代价。无利润区的确存在，并且已在全球蔓延，有愈演愈烈之势。它席卷了数以千计的公司，涉
  • Unity3D 制作MMORPG 3D地图编辑器详解 Thomas_YXQ 3d编辑器Unity3D游戏开发unity开发语言
    前言在MMORPG游戏中，地图编辑器是一个非常重要的工具，可以帮助开发者快速创建复杂的游戏地图。本文将详细介绍如何使用Unity3D制作一个简单的MMORPG3D地图编辑器。对惹，这里有一个游戏开发交流小组，希望大家可以点击进来一起交流一下开发经验呀！创建地图编辑器界面首先，我们需要创建一个新的Unity项目，并在场景中创建一个空的GameObject作为地图编辑器的主要控制器。然后，我们可以使用
  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法 杰哥在此 Java系列javajvm算法面试
    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
  • Vue 模版编译原理 I will.874 vue.jsjavascript前端
    当我们使用Vue编写完一个组件以后，Vue会根据模版编译一个render函数，调用render函数生成虚拟DOM，然后将虚拟DOM映射成真实DOM当数据发生变化时，Vue会触发更新视图，调用render函数返回新的虚拟DOM，对比新旧虚拟DOM，修改真实DOM，从而更新页面在此期间，有以下4个关键步骤：模版编译。生成渲染函数render执行render函数生成虚拟DOM首次渲染，根据虚拟DOM生成
  • 【Git安装及使用学习笔记】 可可西里啊 零零散散的学习笔记git学习笔记c++qt5
    Git学习笔记Git安装Git创建本地版本库以及提交文件使用Git提交代码到码云使用Git从码云拉取代码参考博客Git安装这里参考Git详细安装教程（详解Git安装过程的每一个步骤）Git创建本地版本库以及提交文件1.查看git版本信息：git--version2.设置对应用户名与邮箱地址gitconfig--globaluser.name"your_usernamegitconfig--glob
  • DCGAN中的生成器和识别器代码详解 YYLin-AI DCGAN深度学习celebatensorflow
    #DCGAN中的生成器我自己写的有一个封装好的用于生成器和识别器的卷积操作但是在这个代码中我没有使用我自己的代码#原因想绍一下tensorflow自带的函数所以找了一个以前在书上的代码申明一下这个不是原创但是原来代码中有几处不符合DCGAN的要求所以就做了一些修改转载链接没有就直接写成原创建议看代码之前先看看DCGAN的特点，然后再看代码中如何实这些特点的这样会更有帮助DCGAN（深度卷积的对抗生
  • JSON与AJAX：网页交互的利器 入冉心 jsonajax前端
    在现代Web开发中，JSON（JavaScriptObjectNotation）和AJAX（AsynchronousJavaScriptandXML）是两项不可或缺的技术。它们共同为网页提供了动态、实时的数据交互能力，为用户带来了更加流畅和丰富的体验。本文将详细介绍JSON和AJAX的概念、原理，并通过代码示例展示它们在实际开发中的应用。一、JSON：轻量级的数据交换格式JSON是一种轻量级的数据
  • 【循环神经网络rnn】一篇文章讲透 CX330的烟花 rnn人工智能深度学习算法python机器学习数据结构
    目录引言二、RNN的基本原理代码事例三、RNN的优化方法1长短期记忆网络（LSTM）2门控循环单元（GRU）四、更多优化方法1选择合适的RNN结构2使用并行化技术3优化超参数4使用梯度裁剪5使用混合精度训练6利用分布式训练7使用预训练模型五、RNN的应用场景1自然语言处理2语音识别3时间序列预测六、RNN的未来发展七、结论引言众所周知，CNN与循环神经网络（RNN）或生成对抗网络（GAN）等算法结
  • html版本号 webpack_html-webpack-plugin详解 weixin_39994949 html版本号webpack
    引言最近在react项目中初次用到了html-webapck-plugin插件，用到该插件的两个主要作用：为html文件中引入的外部资源如script、link动态添加每次compile后的hash，防止引用缓存的外部文件问题可以生成创建html入口文件，比如单页面可以生成一个html文件入口，配置N个html-webpack-plugin可以生成N个页面入口有了这种插件，那么在项目中遇到类似上面
  • webpack-loader详解 奶昔不会射手 webpack前端node.js
    一、loader的分类1.pre:前置loader2.normal:普通loader3.inline:内联loader4.post:后置loader二、执行顺序pre>normal>inline>post,相同类型的loader执行顺序为：从右到左，从下到上module:{rules:[{enforce:"pre",//通过这个参数来定义loader的类型，默认是normal类型test:/\.j
  • 408-计算机组成原理-注意点 猫毛已经快要掉光的小猫 系统架构
    数据的表示IEEE754标准的特殊情况：阶码全为0，尾数不全为0表示非规格化的数值，0.M×2^(-126)阶码全为0，尾数也全为0，表示±0阶码全为1，尾数全为0，表示正负无穷大阶码全为1，尾数不全为0，表示非数符Nan存储器Cache：多少组相联指的是一组有多少个。LRU标记为一组有n个，就需要用logn表示区分计算cache数据区与cache容量，cache容量需要包括标志位。标志位大体包括
  • Java学习笔记04：Java_数组 JasonYangQ Javajava
    文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
  • list.sort()&&Collections.sort()深入理解 有点野的程序猿 经验总结listjava数据库开发语言
    list.sort()&&Collections.sort()文章目录list.sort()&&Collections.sort()背景相关代码代码一代码二原理举一反三业务场景考虑背景业务中经常用到List的sort()方法，但是对于其中return的-1，0，1理解不到位，导致业务出现错误；网上对于-1，0，1的表述并不是很清楚，今天详细聊一聊。相关代码先分享两段代码业务逻辑：通过student
  • npm 常用命令详解 马卫斌 前端工程师 npm
    npm（NodePackageManager）是Node.js的包管理器，它允许用户方便地安装、共享和管理Node.js项目中的依赖。以下是一些npm常用命令的详解：1.查看npm版本npm-v这个命令用于查看本地已安装的npm版本。2.初始化项目npminit运行这个命令会引导你创建一个package.json文件，该文件包含了项目的元数据，如名称、版本、描述、作者等信息以及项目的依赖配置。若要
  • 自媒体运营培训机构，全媒体运营师 配音新手圈
    一、自媒体运营培训的重要性自媒体运营培训对于想要在自媒体领域发展的人来说非常重要。兼职副业推荐公众号，配音新手圈，声优配音圈，新配音兼职圈，配音就业圈，鼎音副业，有声新手圈，每天更新各种远程工作与在线兼职，职位包括：写手、程序开发、剪辑、设计、翻译、配音、无门槛、插画、翻译、等等。。。每日更新兼职。通过培训，可以了解自媒体运营的基本原理和技巧，提高自己的运营能力和实战经验。二、如何选择合适的自媒体
  • 【编译原理】一篇就够了——学习笔记与课程实验超详细整理 一棵___大树 编译原理学习笔记学习算法
    ⭐⭐⭐⭐⭐⭐Github主页https://github.com/A-BigTree更多学习笔记链接https://github.com/A-BigTree/college_assignment编译原理实验https://github.com/A-BigTree/college_assignment/compiler_Experiment如果可以，麻烦各位看官顺手点个star~如果文章对你有所帮助
  • 抖音返利平台哪个最高？叫什么？详解抖音返利平台哪个最高 全网优惠分享
    我想大家都在疑惑抖音返利平台哪个最高？叫什么？今天就为大家详解抖音返利平台哪个最高1.氧惠你平时在淘宝买东西，你通过氧惠依然是去淘宝买东西，你平时是在拼多多买东西，你通过氧惠还是去拼多多买东西，该在哪里买还是在哪里买，该买什么还是买什么。但是通过氧惠，不仅可以省钱，还可以赚钱，只要用户注册氧惠就可以享受超级折扣特权。比如你正常充话费是不是没有折扣？充100就是100，就算便宜也就便宜几毛钱，而在氧
  • Java学习笔记：atomic的实现原理？ 曲钟人散
    在多线程的场景中，我们需要保证数据安全，就会考虑同步的方案，通常会使用synchronized或者lock来处理，使用了synchronized意味着内核态的一次切换。这是一个很重的操作。有没有一种方式，可以比较便利的实现一些简单的数据同步，比如计数器等等。concurrent包下的atomic提供我们这么一种轻量级的数据同步的选择。classMyThreadimplementsRunnable{
  • 汲取智慧力量 践行使命担当 正直的男青年
    《习近平谈治国理政》第四卷是马克思主义中国化时代化最新成果，是全面系统反映习近平新时代中国特色社会主义思想的权威著作。通过细读原著原文，咀嚼原汁原味，领悟原义原理，深刻感悟到：作为组工干部，需要以更加振奋的精神、更加踏实的作风、更加创新的方法、更加高效的落实，打牢底子、勇挑担子，以实干实绩彰显组工担当。一要坚定理想信念，始终忠心向党。《习近平谈治国理政》第四卷中提到：“各级党员、干部特别是领导干部
  • 二进制 补码 运算 starnight_cbj 计算机基础扩展
    负数在计算机中如何表示？举例来说，+8在计算机中表示为二进制的1000，那么-8怎么表示呢？很容易想到，可以将一个二进制位（bit）专门规定为符号位，它等于0时就表示正数，等于1时就表示负数。比如，在8位机中，规定每个字节的最高位为符号位。那么，+8就是00001000，而-8则是10001000。但是，随便找一本《计算机原理》，都会告诉你，实际上，计算机内部采用补码（Two'sComplemen
  • 遍历dom 并且存储（将每一层的DOM元素存在数组中） 换个号韩国红果果 JavaScripthtml
    数组从0开始！！ var a=[],i=0; for(var j=0;j<30;j++){ a[j]=[];//数组里套数组，且第i层存储在第a[i]中 } function walkDOM(n){ do{ if(n.nodeType!==3)//筛选去除#text类型 a[i].push(n); //con
  • Android+Jquery Mobile学习系列(9)-总结和代码分享 白糖_ JQuery Mobile
    目录导航   经过一个多月的边学习边练手，学会了Android基于Web开发的毛皮，其实开发过程中用Android原生API不是很多，更多的是HTML/Javascript/Css。   个人觉得基于WebView的Jquery Mobile开发有以下优点： 1、对于刚从Java Web转型过来的同学非常适合，只要懂得HTML开发就可以上手做事。 2、jquerym
  • impala参考资料 dayutianfei impala
    记录一些有用的Impala资料   1. 入门资料 >>官网翻译：     http://my.oschina.net/weiqingbin/blog?catalog=423691   2. 实用进阶 >>代码&架构分析：     Impala/Hive现状分析与前景展望：http
  • JAVA 静态变量与非静态变量初始化顺序之新解 周凡杨 java静态非静态顺序
    今天和同事争论一问题，关于静态变量与非静态变量的初始化顺序，谁先谁后，最终想整理出来！测试代码： import java.util.Map; public class T { public static T t = new T(); private Map map = new HashMap(); public T(){ System.out.println(&quo
  • 跳出iframe返回外层页面 g21121 iframe
    在web开发过程中难免要用到iframe，但当连接超时或跳转到公共页面时就会出现超时页面显示在iframe中，这时我们就需要跳出这个iframe到达一个公共页面去。 首先跳转到一个中间页，这个页面用于判断是否在iframe中，在页面加载的过程中调用如下代码： <script type="text/javascript"> //<!-- function
  • JAVA多线程监听JMS、MQ队列 510888780 java多线程
    背景：消息队列中有非常多的消息需要处理，并且监听器onMessage（）方法中的业务逻辑也相对比较复杂，为了加快队列消息的读取、处理速度。可以通过加快读取速度和加快处理速度来考虑。因此从这两个方面都使用多线程来处理。对于消息处理的业务处理逻辑用线程池来做。对于加快消息监听读取速度可以使用1.使用多个监听器监听一个队列；2.使用一个监听器开启多线程监听。 对于上面提到的方法2使用一个监听器开启多线
  • 第一个SpringMvc例子 布衣凌宇 spring mvc
    第一步：导入需要的包； 第二步：配置web.xml文件 <?xml version="1.0" encoding="UTF-8"?> <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi=
  • 我的spring学习笔记15-容器扩展点之PropertyOverrideConfigurer aijuans Spring3
    PropertyOverrideConfigurer类似于PropertyPlaceholderConfigurer，但是与后者相比，前者对于bean属性可以有缺省值或者根本没有值。也就是说如果properties文件中没有某个bean属性的内容，那么将使用上下文（配置的xml文件）中相应定义的值。如果properties文件中有bean属性的内容，那么就用properties文件中的值来代替上下
  • 通过XSD验证XML antlove xmlschemaxsdvalidationSchemaFactory
    1. XmlValidation.java package xml.validation; import java.io.InputStream; import javax.xml.XMLConstants; import javax.xml.transform.stream.StreamSource; import javax.xml.validation.Schem
  • 文本流与字符集 百合不是茶 PrintWrite()的使用字符集名字 别名获取
    文本数据的输入输出;           输入;数据流,缓冲流         输出;介绍向文本打印格式化的输出PrintWrite();   package 文本流; import java.io.FileNotFound
  • ibatis模糊查询sqlmap-mapping-**.xml配置 bijian1013 ibatis
            正常我们写ibatis的sqlmap-mapping-*.xml文件时，传入的参数都用##标识，如下所示： <resultMap id="personInfo" class="com.bijian.study.dto.PersonDTO"> <res
  • java jvm常用命令工具——jdb命令(The Java Debugger) bijian1013 javajvmjdb
            用来对core文件和正在运行的Java进程进行实时地调试，里面包含了丰富的命令帮助您进行调试，它的功能和Sun studio里面所带的dbx非常相似，但 jdb是专门用来针对Java应用程序的。         现在应该说日常的开发中很少用到JDB了，因为现在的IDE已经帮我们封装好了，如使用ECLI
  • 【Spring框架二】Spring常用注解之Component、Repository、Service和Controller注解 bit1129 controller
    在Spring常用注解第一步部分【Spring框架一】Spring常用注解之Autowired和Resource注解（http://bit1129.iteye.com/blog/2114084）中介绍了Autowired和Resource两个注解的功能，它们用于将依赖根据名称或者类型进行自动的注入，这简化了在XML中，依赖注入部分的XML的编写，但是UserDao和UserService两个bea
  • cxf wsdl2java生成代码super出错,构造函数不匹配 bitray super
        由于过去对于soap协议的cxf接触的不是很多,所以遇到了也是迷糊了一会.后来经过查找资料才得以解决. 初始原因一般是由于jaxws2.2规范和jdk6及以上不兼容导致的.所以要强制降为jaxws2.1进行编译生成.我们需要少量的修改: 我们原来的代码 wsdl2java com.test.xxx -client http://..... 修改后的代
  • 动态页面正文部分中文乱码排障一例 ronin47
    公司网站一部分动态页面，早先使用apache+resin的架构运行，考虑到高并发访问下的响应性能问题，在前不久逐步开始用nginx替换掉了apache。 不过随后发现了一个问题，随意进入某一有分页的网页，第一页是正常的（因为静态化过了）；点“下一页”，出来的页面两边正常，中间部分的标题、关键字等也正常，唯独每个标题下的正文无法正常显示。 因为有做过系统调整，所以第一反应就是新上
  • java-54- 调整数组顺序使奇数位于偶数前面 bylijinnan java
    import java.util.Arrays; import java.util.Random; import ljn.help.Helper; public class OddBeforeEven { /** * Q 54 调整数组顺序使奇数位于偶数前面 * 输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半
  • 从100PV到1亿级PV网站架构演变 cfyme 网站架构
    一个网站就像一个人，存在一个从小到大的过程。养一个网站和养一个人一样，不同时期需要不同的方法，不同的方法下有共同的原则。本文结合我自已14年网站人的经历记录一些架构演变中的体会。 1：积累是必不可少的 架构师不是一天练成的。 1999年，我作了一个个人主页，在学校内的虚拟空间，参加了一次主页大赛，几个DREAMWEAVER的页面，几个TABLE作布局，一个DB连接，几行PHP的代码嵌入在HTM
  • [宇宙时代]宇宙时代的GIS是什么？ comsci Gis
           我们都知道一个事实，在行星内部的时候，因为地理信息的坐标都是相对固定的，所以我们获取一组GIS数据之后，就可以存储到硬盘中，长久使用。。。但是，请注意，这种经验在宇宙时代是不能够被继续使用的          宇宙是一个高维时空
  • 详解create database命令 czmmiao database
    完整命令 CREATE DATABASE mynewdb   USER SYS IDENTIFIED BY sys_password   USER SYSTEM IDENTIFIED BY system_password   LOGFILE GROUP 1 ('/u01/logs/my/redo01a.log','/u02/logs/m
  • 几句不中听却不得不认可的话 datageek
    1、人丑就该多读书。 2、你不快乐是因为：你可以像猪一样懒，却无法像只猪一样懒得心安理得。 3、如果你太在意别人的看法，那么你的生活将变成一件裤衩，别人放什么屁，你都得接着。 4、你的问题主要在于：读书不多而买书太多，读书太少又特爱思考，还他妈话痨。 5、与禽兽搏斗的三种结局：(1)、赢了，比禽兽还禽兽。(2)、输了，禽兽不如。(3)、平了，跟禽兽没两样。结论：选择正确的对手很重要。 6
  • 1 14:00 PHP中的“syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM”错误 dcj3sjt126com PHP
    原文地址：http://www.kafka0102.com/2010/08/281.html   因为需要，今天晚些在本机使用PHP做些测试，PHP脚本依赖了一堆我也不清楚做什么用的库。结果一跑起来，就报出类似下面的错误：“Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM in /home/kafka/test/
  • xcode6 Auto layout and size classes dcj3sjt126com ios
    官方GUI   https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/AutolayoutPG/Introduction/Introduction.html   iOS中使用自动布局（一）   http://www.cocoachina.com/ind
  • 通过PreparedStatement批量执行sql语句【sql语句相同，值不同】 梦见x光 sql事务批量执行
    比如说：我有一个List需要添加到数据库中，那么我该如何通过PreparedStatement来操作呢？ public void addCustomerByCommit(Connection conn , List<Customer> customerList) {    String sql = "inseret into customer(id
  • 程序员必知必会----linux常用命令之十【系统相关】 hanqunfeng Linux常用命令
    一.linux快捷键 Ctrl+C : 终止当前命令 Ctrl+S : 暂停屏幕输出 Ctrl+Q : 恢复屏幕输出 Ctrl+U : 删除当前行光标前的所有字符 Ctrl+Z : 挂起当前正在执行的进程 Ctrl+L : 清除终端屏幕，相当于clear   二.终端命令 clear : 清除终端屏幕 reset : 重置视窗，当屏幕编码混乱时使用 time com
  • NGINX IXHONG nginx
    pcre 编译安装 nginx conf/vhost/test.conf   upstream admin { server 127.0.0.1:8080; }   server {                 listen       80; &
  • 设计模式--工厂模式 kerryg 设计模式
    工厂方式模式分为三种：   1、普通工厂模式：建立一个工厂类，对实现了同一个接口的一些类进行实例的创建。   2、多个工厂方法的模式：就是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式就是提供多个工厂方法，分别创建对象。   3、静态工厂方法模式：就是将上面的多个工厂方法模式里的方法置为静态，
  • Spring InitializingBean/init-method和DisposableBean/destroy-method mx_xiehd javaspringbeanxml
    1.initializingBean/init-method 实现org.springframework.beans.factory.InitializingBean接口允许一个bean在它的所有必须属性被BeanFactory设置后，来执行初始化的工作，InitialzingBean仅仅指定了一个方法。 通常InitializingBean接口的使用是能够被避免的，（不鼓励使用，因为没有必要
  • 解决Centos下vim粘贴内容格式混乱问题 qindongliang1922 centosvim
    有时候，我们在向vim打开的一个xml，或者任意文件中，拷贝粘贴的代码时，格式莫名其毛的就混乱了，然后自己一个个再重新，把格式排列好，非常耗时，而且很不爽，那么有没有办法避免呢？ 答案是肯定的，设置下缩进格式就可以了，非常简单： 在用户的根目录下 直接vi  ~/.vimrc文件 然后将set pastetoggle=<F9> 写入这个文件中，保存退出，重新登录，
  • netty大并发请求问题 tianzhihehe netty
    多线程并发使用同一个channel java.nio.BufferOverflowException: null at java.nio.HeapByteBuffer.put(HeapByteBuffer.java:183) ~[na:1.7.0_60-ea] at java.nio.ByteBuffer.put(ByteBuffer.java:832) ~[na:1.7.0_60-ea]
  • Hadoop NameNode单点问题解决方案之一 AvatarNode wyz2009107220 NameNode
    我们遇到的情况 Hadoop NameNode存在单点问题。这个问题会影响分布式平台24*7运行。先说说我们的情况吧。 我们的团队负责管理一个1200节点的集群(总大小12PB)，目前是运行版本为Hadoop 0.20，transaction logs写入一个共享的NFS filer(注：NetApp NFS Filer)。 经常遇到需要中断服务的问题是给hadoop打补丁。 DataNod
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他