Android 内存溢出（OOM）的 Kotlin 排查与优化指南

内存溢出（Out Of Memory, OOM）是 Android 开发中常见且棘手的问题，尤其在处理大图、复杂数据或内存泄漏时。本文将通过 Kotlin 代码示例 和工具使用，提供一套比较完整的排查与优化方案。

一、检测工具：定位内存问题根源

1. Android Profiler 实时监控

• 操作流程：

  1. 打开 Android Studio → Run App → 点击底部 Profiler 选项卡。
  2. 选择 Memory 模块，观察内存波动，点击 Dump Heap 生成堆快照。
  3. 使用 Allocation Tracking 记录对象分配。

• 关键指标：

  • Java Heap：关注持续增长的未回收对象。
  • Native Heap：排查 JNI 或第三方库泄漏。

2. 使用 LeakCanary 自动化检测

• 集成与使用：

  // build.gradle
  dependencies {
    debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.12'
  }
  
  // Application 类中初始化
  class MyApp : Application() {
    override fun onCreate() {
      super.onCreate()
      if (LeakCanary.isInAnalyzerProcess(this)) return
      LeakCanary.config = LeakCanary.config.copy(retainedVisibleThreshold = 1)
    }
  }
  

  LeakCanary 会自动检测 Activity/Fragment 泄漏并生成报告。

二、代码陷阱：Kotlin 中常见内存泄漏场景

1. Lambda 与匿名内部类泄漏

• 错误代码：

  class MyActivity : AppCompatActivity() {
      private val heavyData = HeavyData()
  
      override fun onCreate(savedInstanceState: Bundle?) {
          super.onCreate(savedInstanceState)
          // 匿名内部类隐式持有 MyActivity 引用
          button.setOnClickListener {
              heavyData.process() // 导致 Activity 无法回收
          }
      }
  }
  

• 修复方案：

  class SafeClickListener(
      private val weakActivity: WeakReference<MyActivity>
  ) : View.OnClickListener {
      override fun onClick(v: View?) {
          weakActivity.get()?.heavyData?.process()
      }
  }
  
  // 在 Activity 中使用
  button.setOnClickListener(SafeClickListener(WeakReference(this)))
  

2. 静态变量持有 Context 或 View

• 错误代码：

  object GlobalHolder {
      var currentActivity: Activity? = null // 静态变量持有 Activity
  }
  
  class MyActivity : AppCompatActivity() {
      override fun onCreate(savedInstanceState: Bundle?) {
          super.onCreate(savedInstanceState)
          GlobalHolder.currentActivity = this // 导致泄漏
      }
  }
  

• 修复方案：

  object GlobalHolder {
      private val weakContext = WeakReference<Context>(null)
  
      fun setContext(context: Context) {
          weakContext.clear()
          weakContext.get() = context.applicationContext // 使用 Application Context
      }
  }
  

三、优化实践：关键代码示例

1. Bitmap 内存优化

• 加载大图的正确方式：

  fun loadOptimizedBitmap(context: Context, resId: Int): Bitmap {
      val options = BitmapFactory.Options().apply {
          inJustDecodeBounds = true // 先读取尺寸
          BitmapFactory.decodeResource(context.resources, resId, this)
          inSampleSize = calculateInSampleSize(this, 300, 300) // 计算缩放比例
          inJustDecodeBounds = false
          inPreferredConfig = Bitmap.Config.RGB_565 // 减少内存占用 50%
      }
      return BitmapFactory.decodeResource(context.resources, resId, options)
  }
  
  private fun calculateInSampleSize(options: Bitmap.Options, reqWidth: Int, reqHeight: Int): Int {
      val (height, width) = options.run { outHeight to outWidth }
      var inSampleSize = 1
      if (height > reqHeight || width > reqWidth) {
          val halfHeight = height / 2
          val halfWidth = width / 2
          while (halfHeight / inSampleSize >= reqHeight && 
                 halfWidth / inSampleSize >= reqWidth) {
              inSampleSize *= 2
          }
      }
      return inSampleSize
  }
  

2. 使用协程避免生命周期泄漏

• ViewModel 中正确使用协程：

  class MyViewModel : ViewModel() {
      private val _data = MutableStateFlow<List<Data>>(emptyList())
      val data: StateFlow<List<Data>> = _data
  
      fun loadData() {
          viewModelScope.launch { // 自动跟随 ViewModel 生命周期
              val result = withContext(Dispatchers.IO) {
                  fetchDataFromNetwork() // 模拟耗时操作
              }
              _data.value = result
          }
      }
  }
  

3. 集合与缓存清理

• 及时释放无用数据：

  class ImageCache {
      private val cache = LruCache<String, Bitmap>(maxMemory / 8) // LRU 缓存
  
      fun addBitmap(key: String, bitmap: Bitmap) {
          cache.put(key, bitmap)
      }
  
      fun clearUnused() {
          cache.evictAll() // 主动清理
      }
  }
  
  // 在 Activity 的 onDestroy() 中调用
  override fun onDestroy() {
      super.onDestroy()
      imageCache.clearUnused()
  }
  

四、高级技巧：Native 内存与性能分析

1. 追踪 Native 内存泄漏

• 使用 Android Profiler 的 Native Memory 跟踪：
  1. 连接设备并启动 Profiler。
  2. 进入 Memory 模块，选择 Native Memory。
  3. 点击 Start Recording 记录 Native 内存分配。

2. 启用 StrictMode 检测

• 在 Application 中配置：

  class MyApp : Application() {
      override fun onCreate() {
          super.onCreate()
          StrictMode.setVmPolicy(
              StrictMode.VmPolicy.Builder()
                  .detectActivityLeaks()     // Activity 泄漏
                  .detectLeakedClosableObjects() // 未关闭的 Closeable
                  .penaltyLog()
                  .build()
          )
      }
  }
  

五、完整流程图：OOM 排查步骤

1. 复现问题 → 2. Android Profiler 监控内存 → 3. 生成 Heap Dump → 4. 分析大对象/重复对象 → 
5. LeakCanary 检测泄漏 → 6. 检查代码陷阱（静态变量/Lambda/Bitmap） → 
7. 优化数据结构/分页加载 → 8. 回归测试验证

六、总结与最佳实践

• 关键原则：
  1. 早检测：集成 LeakCanary，开发阶段发现问题。
  2. 轻量化：使用 RGB_565 Bitmap、SparseArray 等优化内存。
  3. 生命周期感知：通过 viewModelScope/lifecycleScope 管理协程。
  4. 及时释放：在 onDestroy() 中清理集合、关闭资源。

通过工具分析、代码审查与优化策略的结合，可显著降低 OOM 发生概率。建议在代码 Review 中重点关注静态变量、匿名内部类和大图处理，同时定期使用 Profiler 进行性能巡检。