Lambda作为输入参数导致Compose重组的原因及优化方案

问题场景 #

参考以下代码片段：

fun doSomething(){
}

@Composable
fun A() {
    Column() {
        val counter = remember { mutableStateOf(0) }
        B {
            doSomething()
        }
        Button(onClick = { counter.value += 1 }) {
            Text("Click me 2")
        }
        Text(text = "count: ${counter.value}")
    }
}

@Composable
fun B(onClick: () -> Unit) {
    Button(onClick = onClick) {
        Text("click me")
    }
}

点击「Click me 2」按钮时，counter状态更新会触发A重组，但B组件内部没有任何状态变化，却也跟着发生了重组。实际场景中，B的Lambda参数可能包含协程操作，比如：

B{
    coroutineScope.launch{
        bottomSheetState.collapse()
        doSomething()
    }
}

核心问题解答 #

1. Lambda为何会引发B组件重组？ #

Compose判断是否跳过重组的核心依据是输入参数的稳定性与是否发生变化。虽然B是skippable函数，onClick也被标记为stable类型，但这里的Lambda是在A重组时每次都重新创建的新实例——哪怕Lambda内部逻辑完全一致，它也是一个全新的对象，Compose会判定B的输入参数发生了变化，因此触发重组。

你提到的「Lambda内包含状态变更操作则不会触发重组」，本质是因为当Lambda捕获了mutableState这类状态时，Compose编译器会将其标记为restartable。此时重组时，不会因为Lambda实例变化就触发子组件重组，而是会检查Lambda内部捕获的状态是否真的有变化。但如果Lambda没有捕获任何状态（或捕获的是稳定的无状态对象），编译器无法做这个优化，每次重组都会生成新的Lambda实例，导致B被迫重组。

2. 最优解决方案 #

根据场景不同，推荐以下优先级从高到低的方案：

方案1：使用函数引用（最简洁，优先考虑）

如果Lambda内部只是调用无状态的函数，直接用函数引用代替Lambda。函数引用是单例实例，每次重组时都是同一个对象，不会触发B的重组：

// 直接传递函数引用
B(::doSomething)

如果是ViewModel中的方法，同样可以用viewModel::doSomething，只要方法本身不捕获不稳定状态，就能保证参数稳定性。

方案2：用remember缓存Lambda（通用方案）

当Lambda需要捕获变量（比如实际场景中的coroutineScope、bottomSheetState），无法使用函数引用时，用remember缓存Lambda实例，确保每次重组时传递的都是同一个对象：

val action = remember(coroutineScope, bottomSheetState) {
    {
        coroutineScope.launch {
            bottomSheetState.collapse()
            doSomething()
        }
    }
}
B(action)

注意要把Lambda捕获的所有不稳定变量作为remember的key，只有当这些变量变化时，才重新创建Lambda，否则复用之前的实例。

方案3：封装为稳定类实例（复杂场景）

如果Lambda逻辑复杂或需要多次复用，可以将其封装成稳定类的实例，通过remember持有：

class MyAction(
    private val coroutineScope: CoroutineScope,
    private val bottomSheetState: BottomSheetState
) {
    operator fun invoke() {
        coroutineScope.launch {
            bottomSheetState.collapse()
            doSomething()
        }
    }
}

// 在Compose中使用
val action = remember(coroutineScope, bottomSheetState) {
    MyAction(coroutineScope, bottomSheetState)
}
B(action::invoke)

这种方式适合复杂场景，但一般前两种方案就能覆盖大多数情况。

补充说明 #

Compose重组优化的核心是保证输入参数的稳定性，只要子组件的输入参数在重组时没有变化，就能跳过不必要的重组。对于Lambda，要么让它成为稳定的单例（函数引用），要么用remember缓存实例，避免每次重组都生成新对象。

内容的提问来源于stack exchange，提问作者Ali Golmirzaei