Jetpack Compose生命周期：Composable与LaunchedEffect对比

1. 生命周期机制的本质差异

在Jetpack Compose中，Composable函数和LaunchedEffect虽然都涉及生命周期管理，但两者的设计目标和运行机制存在根本性区别。Composable函数是声明式UI的基本构建块，其生命周期与视图的显示状态直接关联；而LaunchedEffect是副作用处理工具，其生命周期与协程作用域绑定。

1.1 Composable的生命周期阶段

典型的Composable生命周期包含以下关键阶段：

1. Active（活跃期）：组件首次进入组合或重组时触发，对应onActive回调
2. Update（更新期）：当依赖状态变化时触发重组
3. Dispose（销毁期）：组件从组合树移除时触发清理

kotlin复制@Composable
fun LifecycleDemo() {
    DisposableEffect(Unit) {
        onDispose { println("Component disposed") }
        println("Component active")
        onDispose {  }
    }
}

1.2 LaunchedEffect的协程作用域

LaunchedEffect的生命周期完全由其所在的Composable决定：

• 启动时机：当key参数变化或首次组合时
• 取消时机：当Composable离开组合或key变化时
• 重启行为：key变化会导致当前协程取消并启动新协程

关键区别：LaunchedEffect的协程作用域不会在重组时自动重启，除非显式指定key参数

2. 核心使用场景对照

2.1 Composable的典型应用

• UI布局构建
• 状态驱动的内容渲染
• 组合式组件的嵌套管理
• 与remember API配合管理本地状态

kotlin复制@Composable
fun CounterDisplay() {
    var count by remember { mutableStateOf(0) }
    Button(onClick = { count++ }) {
        Text("Clicked $count times")
    }
}

2.2 LaunchedEffect的适用场景

• 一次性异步操作（如网络请求）
• 动画控制
• 事件订阅管理
• 与其他协程API的集成

kotlin复制@Composable
fun DataFetcher() {
    var data by remember { mutableStateOf<String?>(null) }
    
    LaunchedEffect(Unit) {
        data = fetchFromNetwork()
    }
    
    data?.let { Text(it) } ?: CircularProgressIndicator()
}

3. 生命周期事件对照表

4. 实战中的关键差异

4.1 状态访问方式

Composable函数中：

• 直接读取状态会建立隐式依赖
• 每次重组都会重新计算派生状态

LaunchedEffect中：

• 必须通过remember或外部参数获取状态
• 协程内部捕获的状态值会保持初始值

kotlin复制@Composable
fun StateCaptureDemo() {
    var count by remember { mutableStateOf(0) }
    
    LaunchedEffect(Unit) {
        println("Initial count: $count") // 捕获初始值
        delay(1000)
        println("Current count: $count") // 仍然显示初始值
    }
    
    Button(onClick = { count++ }) {
        Text("Increment")
    }
}

4.2 性能优化策略

对于Composable：

• 使用remember缓存计算结果
• 通过derivedStateOf优化频繁更新
• 拆分细粒度组件减少重组范围

对于LaunchedEffect：

• 合理设置key避免不必要的重启
• 使用coroutineScope管理多个协程
• 在副作用中避免阻塞操作

5. 常见问题解决方案

5.1 无限循环问题

错误示例：

kotlin复制@Composable
fun InfiniteLoop() {
    var count by remember { mutableStateOf(0) }
    
    LaunchedEffect(count) { // 每次更新都会触发新的LaunchedEffect
        count++
    }
}

正确做法：

kotlin复制@Composable
fun SafeCounter() {
    var count by remember { mutableStateOf(0) }
    
    LaunchedEffect(Unit) {
        while(true) {
            delay(1000)
            count++ // 在同一个协程内安全更新
        }
    }
}

5.2 副作用清理遗漏

风险代码：

kotlin复制@Composable
fun RiskySubscription() {
    LaunchedEffect(Unit) {
        val eventStream = registerEventStream()
        eventStream.collect { ... }
        // 缺少取消订阅逻辑
    }
}

安全实现：

kotlin复制@Composable
fun SafeSubscription() {
    LaunchedEffect(Unit) {
        val eventStream = registerEventStream()
        try {
            eventStream.collect { ... }
        } finally {
            eventStream.unregister()
        }
    }
}

6. 高级模式与组合技巧

6.1 嵌套副作用管理

当需要组合多个副作用时，推荐使用coroutineScope构建器：

kotlin复制@Composable
fun MultiEffect() {
    LaunchedEffect(Unit) {
        coroutineScope {
            launch { handleAnimation() }
            launch { monitorEvents() }
        }
    }
}

6.2 与remember的协同使用

结合remember可以创建持久化的副作用控制器：

kotlin复制@Composable
fun PersistentEffect() {
    val controller = remember {
        object {
            var job: Job? = null
            fun start(scope: CoroutineScope) {
                job = scope.launch { ... }
            }
            fun cancel() { job?.cancel() }
        }
    }
    
    DisposableEffect(Unit) {
        controller.start(this)
        onDispose { controller.cancel() }
    }
}

在实际项目中，我发现合理使用LaunchedEffect的关键在于明确区分"触发条件"和"执行逻辑"。对于需要响应式处理的场景，应该将变化因素提取为key参数；而对于需要持续运行的逻辑，则应该使用固定key并内部处理状态变化。