Android内存优化：当LeakCanary遇上协程，内存泄漏治理进入新阶段

class UserRepository(
private val context: Context,  // Application Context，看似安全
private val scope: CoroutineScope  // 外部传入的 scope，危险点
) {
fun startPolling() {
scope.launch {
while (isActive) {
fetchUser()
delay(5000)
}
}
}
}// 调用方：某个 Fragment
class ProfileFragment : Fragment() {
private val repo = UserRepository(
requireContext().applicationContext,
lifecycleScope  // Fragment 的 lifecycleScope
)
}

// 在协程里捕获了 View 的引用
viewModelScope.launch {
val bitmap = withContext(Dispatchers.IO) {
BitmapFactory.decodeResource(view.resources, R.drawable.banner) // 捕获了 view
}
imageView.setImageBitmap(bitmap)
}

// LeakCanary 3.0 alpha 的新 API（实验性）
class MyViewModel : ViewModel() {
init {
// 自动监视 viewModelScope 下所有协程的生命周期
AppWatcher.objectWatcher.expectWeaklyReachable(
this,
"ViewModel should be cleared"
)
}
}// 更直接的方式：使用新的扩展函数
viewModelScope.watchForLeaks() // 3.0 新增，自动注册监视点

// 2.x 报告（节选，经常20行以上）
┬───
│ GC Root: Thread
│
├─ kotlinx.coroutines.scheduling.CoroutineScheduler$Worker
│    thread name: DefaultDispatcher-worker-1
│    ↓ CoroutineScheduler$Worker.localQueue
├─ kotlinx.coroutines.scheduling.WorkQueue
│    ↓ WorkQueue.buffer
├─ ...（中间省略10行框架代码）
╰→ com.example.ProfileFragment  ← 真正的问题在这里，但已经被淹没了// 3.0 报告（同样的泄漏）
┬ GC Root: Thread
│  [kotlinx.coroutines 内部，已折叠 8 个节点]
╰→ com.example.ProfileFragment
↓ ProfileFragment.binding (ViewBinding)
↓ FragmentProfileBinding.imageView
LEAK: ImageView held by coroutine lambda

// Coil 3.4.0：自动绑定 Lifecycle，页面销毁时取消加载
AsyncImage(
model = ImageRequest.Builder(LocalContext.current)
.data(imageUrl)
.size(Size.ORIGINAL)
.memoryCachePolicy(CachePolicy.ENABLED)
.diskCachePolicy(CachePolicy.ENABLED)
.build(),
contentDescription = null,
modifier = Modifier.fillMaxWidth()
)// Coil 3.4.0 新增：精细的内存缓存控制
val imageLoader = ImageLoader.Builder(context)
.memoryCache {
MemoryCache.Builder()
.maxSizePercent(context, percent = 0.25) // 最多用25%的可用内存
.build()
}
.bitmapPool(BitmapPool(100 * 1024 * 1024)) // 100MB Bitmap 复用池
.build()

// Glide 5.0：需要手动处理 Compose 的生命周期
val painter = rememberGlidePainter(
request = imageUrl,
requestBuilder = {
override(400, 300) // 明确指定采样尺寸，避免加载全尺寸图
diskCacheStrategy(DiskCacheStrategy.RESOURCE)
}
)
Image(painter = painter, contentDescription = null)// Glide 的内存管理配置（Application 级别）
@GlideModule
class AppGlideModule : AppGlideModule() {
override fun applyOptions(context: Context, builder: GlideBuilder) {
val memoryCacheSizeBytes = 1024 * 1024 * 20 // 20MB
builder.setMemoryCache(LruResourceCache(memoryCacheSizeBytes.toLong()))
builder.setBitmapPool(LruBitmapPool(memoryCacheSizeBytes.toLong()))
}
}

// leakcanary-android-instrumentation 配置
// build.gradle.kts
androidTest {
dependencies {
androidTestImplementation("com.squareup.leakcanary:leakcanary-android-instrumentation:3.0-alpha-8")
}
}// 自定义测试规则：让泄漏导致测试失败
@RunWith(AndroidJUnit4::class)
class LeakTest {
@get:Rule
val rule = DetectLeaksAfterEachTest()@Test
fun testUserFlow() {
// 模拟完整的用户流程
onView(withId(R.id.login_button)).perform(click())
// ...
// 测试结束后自动检测内存泄漏，有泄漏则 FAIL
}
}

object MemoryBaseline {
private val snapshots = mutableMapOf<String, Long>()fun snapshot(pageName: String) {
val runtime = Runtime.getRuntime()
val usedMemory = runtime.totalMemory() - runtime.freeMemory()
snapshots[pageName] = usedMemory
}fun checkDelta(pageName: String, thresholdMb: Int = 10): Boolean {
val currentUsed = Runtime.getRuntime().let { it.totalMemory() - it.freeMemory() }
val baseline = snapshots[pageName] ?: return true
val deltaMb = (currentUsed - baseline) / 1024 / 1024
if (deltaMb > thresholdMb) {
Log.w("MemoryBaseline", "$pageName: 内存增长 ${deltaMb}MB，超过阈值 ${thresholdMb}MB")
if (BuildConfig.DEBUG) {
// Debug 下触发 LeakCanary 强制分析
AppWatcher.objectWatcher.expectWeaklyReachable(
Object(), "$pageName memory spike"
)
}
return false
}
return true
}
}// 在 Fragment 中使用
override fun onResume() {
super.onResume()
MemoryBaseline.snapshot(javaClass.simpleName)
}override fun onPause() {
super.onPause()
MemoryBaseline.checkDelta(javaClass.simpleName)
}

// 线上内存监控（只上报，不触发 heap dump）
class MemoryMonitor {
companion object {
fun startPeriodicCheck(scope: CoroutineScope) {
scope.launch(Dispatchers.Default) {
while (isActive) {
val activityManager = context.getSystemService(ActivityManager::class.java)
val memInfo = ActivityManager.MemoryInfo()
activityManager.getMemoryInfo(memInfo)val usedPercent = (1 - memInfo.availMem.toFloat() / memInfo.totalMem) * 100if (usedPercent > 85f) {
// 内存使用超过85%，上报至监控平台
Analytics.event("memory_pressure", mapOf(
"used_percent" to usedPercent,
"available_mb" to memInfo.availMem / 1024 / 1024,
"page" to currentPage
))
}
delay(30_000) // 每30秒检查一次
}
}
}
}
}

// 看似安全：AndroidViewModel 持有 Application Context
class MyViewModel(application: Application) : AndroidViewModel(application) {
// 但如果你在这里做了这件事：
private val prefs = application.getSharedPreferences("user", Context.MODE_PRIVATE)
.apply {
registerOnSharedPreferenceChangeListener { _, key ->
// 这个 lambda 持有了 MyViewModel 的引用！
// SharedPreferences 默认用 WeakReference 持有 listener，但
// 如果你在别处 strongRef 了这个 listener，就泄漏了
handlePrefChange(key)
}
}
}

// 错误：在 Fragment 里用了 ViewModel 的 scope
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
viewModel.uiState.collect { state ->  // 注意：这里不是 launchWhenStarted，而是直接 collect
updateUI(state)
}
// 这个协程会一直运行，即使 Fragment 退出栈，UI 状态还在被消费
}// 正确：使用 repeatOnLifecycle
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
viewLifecycleOwner.lifecycleScope.launch {
repeatOnLifecycle(Lifecycle.State.STARTED) {
viewModel.uiState.collect { state ->
updateUI(state)
}
}
}
}

suspend fun applyFilter(source: Bitmap): Bitmap = withContext(Dispatchers.Default) {
var intermediate: Bitmap? = null
try {
intermediate = Bitmap.createBitmap(source.width, source.height, Bitmap.Config.ARGB_8888)
// 处理...
val result = Bitmap.createBitmap(intermediate)
result  // 返回最终结果
} finally {
intermediate?.recycle()  // 临时 Bitmap 立刻回收
}
}