Jetpack Compose 中的重组作用域和性能优化

川峰

已于 2023-10-30 19:33:43 修改

阅读量1.4k

点赞数 4

分类专栏： Jetpack Compose 文章标签： android Jetpack Compose 重组作用域性能优化

于 2023-03-06 08:00:00 首次发布

本文链接：https://blog.csdn.net/lyabc123456/article/details/129232729

版权

本文详细介绍了Jetpack Compose中重组作用域的概念及其影响，强调只有读取可变状态的作用域才会被重组。讨论了内联组件的重组作用域、隔离重组作用域的方法，以及如何避免不必要的重组。文章还提到了优化Modifier的状态读取，使用derivedStateOf降低重组次数，以及如何处理lambda回调和log日志带来的性能问题。最后，作者提醒读者关注Compose Compiler的编译报告，以便更好地理解和优化性能。

摘要由CSDN通过智能技术生成

只有读取可变状态的作用域才会被重组

这句话的意思是只有读取 mutableStateOf() 函数生成的状态值的那些 Composable 函数才会被重新执行。注意，这与 mutableStateOf() 函数在什么位置被定义没有关系。读取操作指的是对状态值的 get 操作。也就是取值的操作。

从一个最简单的例子开始：

@Composable
fun Sample() {
   
    Column(
        modifier = Modifier
            .padding(4.dp)
            .shadow(1.dp, shape = CutCornerShape(topEnd = 8.dp))
            .background(getRandomColor())
            .padding(4.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
   
        var counter by remember {
    mutableStateOf(0) }
        Text("Text1", color = Color.White, modifier = Modifier.background(getRandomColor()))
        Button(
            modifier = Modifier.fillMaxWidth(),
            colors = ButtonDefaults.buttonColors(backgroundColor = getRandomColor()),
            onClick = {
    counter++ },
            shape = RoundedCornerShape(5.dp)
        ) {
   
             Text("Text2: counter: $counter", color = Color.White, modifier = Modifier.background(getRandomColor())) 
        }
    }
}
fun getRandomColor() =  Color(
    red = Random.nextInt(256),
    green = Random.nextInt(256),
    blue = Random.nextInt(256),
    alpha = 255
)

在上面的代码中，我们为每个 Composable 组件都设置了一个随机的背景颜色，这样，一旦它们发生了重组，我们就可以观察到。

在这里插入图片描述

这里点击 Button 修改 counter 的值之后，只有读取 counter 的 Text 组件背景色发生变化，这充分的说明了只有这个 Text 组件才会重组。位于 Button 之上的 Text 组件，虽然它与 counter 定义在同一作用域范围内，但是它不会被触发重组，因为它没有读取该 counter 的值。

假如我们把 Button 内的组件换成一个自定义的 Composable 组件，只要它读取 counter 的值，那么该自定义组件的整个作用域范围都会执行重组：

@Composable
private fun Sample1() {
   
    Column(
        modifier = Modifier
            .padding(4.dp)
            .shadow(1.dp, shape = CutCornerShape(topEnd = 8.dp))
            .background(getRandomColor())
            .padding(4.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
   
        var counter by remember {
    mutableStateOf(0) }
        Text("Text1", color = Color.White, modifier = Modifier.background(getRandomColor()))
        Button(
            modifier = Modifier.fillMaxWidth(),
            colors = ButtonDefaults.buttonColors(backgroundColor = getRandomColor()),
            onClick = {
    counter++ },
            shape = RoundedCornerShape(5.dp)
        ) {
    
            MyText(counter)
        }
    }
}

@Composable
fun MyText(counter: Int) {
   
    Column {
   
        Text("MyText: counter: $counter", color = Color.White, modifier = Modifier.background(getRandomColor()))
        Text("Another Text", color = Color.White, modifier = Modifier.background(getRandomColor()))
    }
}

在这里插入图片描述

可以看到，点击修改counter 值的时候，不仅 MyText 组件中的第一个读取 counter 值的 Text 组件会发生重组，而且 MyText 组件中的另一个未读取 counter 值的 Text 组件也发生了重组。也就是说整个 MyText 组件都发生了重组。

内联组件的重组作用域与其调用者相同

在一般情况下，读取某个state值的组件和未读取某个state值的组件，它们的重组作用域是隔离的，互不影响。但是内联组件除外。可以通过下面的例子来说明这个问题：

@Composable
fun Sample() {
   
    Column(
        modifier = Modifier
            .padding(4.dp)
            .shadow(1.dp, shape = CutCornerShape(topEnd = 8.dp))
            .background(getRandomColor())
            .padding(4.dp)
    ) {
   
        var update1 by remember {
    mutableStateOf(0) } 
        
        println("ROOT")
        Text("Text in outer Column", color = Color.White, modifier = Modifier.background(getRandomColor()))

        Button(
            modifier = Modifier.fillMaxWidth(),
            colors = ButtonDefaults.buttonColors(backgroundColor = getRandomColor()),
            onClick = {
    update1++ },
            shape = RoundedCornerShape(5.dp)
        ) {
   
            println("🔥 Button 1")
            Text(
                text = "Text in Button1 read update1: $update1",
                textAlign = TextAlign.Center,
                color = Color.White,
                modifier = Modifier.background(getRandomColor())
            )
        }

        Column(
            modifier = Modifier
                .padding(4.dp)
                .shadow(1.dp, shape = CutCornerShape(topEnd = 8.dp))
                .background(getRandomColor())
                .padding(4.dp)
        ) {
   
            println("🚀 Inner Column")
            var update2 by remember {
    mutableStateOf(0) }
            Button(
                modifier = Modifier.fillMaxWidth(),
                colors = ButtonDefaults.buttonColors(backgroundColor = getRandomColor()),
                onClick = {
    update2++ },
                shape = RoundedCornerShape(5.dp)
            ) {
   
                println("✅ Button 2")
                Text(
                    text = "Text in Button2 read update2: $update2",
                    textAlign = TextAlign.Center,
                    color = Color.White,
                    modifier = Modifier.background(getRandomColor())
                )
            }

            Column(
                modifier = Modifier
                    .padding(4.dp)
                    .shadow(1.dp, shape = CutCornerShape(topEnd = 8.dp))
                    .background(getRandomColor())
                    .padding(6.dp)
            ) {
   
                println("☕ Bottom Column")
                /**
                 * 🔥🔥 Observing update(mutableState) causes entire composable to recompose
                 */
                Text(
                    text = "🔥 Text in Inner Column read update1: $update1",
                    textAlign = TextAlign.Center,
                    color = Color.White,
                    modifier = Modifier.background(getRandomColor())
                )
            }
        } 
    }
}

在这里插入图片描述

当我们点击 Button 2 时，只会影响读取 update2 值的范围，这没有问题。但是我们点击 Button 1 时，整个组件都在为我们闪烁！这并没有像我们预想的那样：只影响 Button 1 中的读取 update1 的 Text 以及内部嵌套 Column 中读取 update1 的 Text 组件。而是影响了整个外部的 Column 组件的作用域。

这是因为 Column 组件是被定义为 inline 内联的。我们可以通过它的源码定义中发现：

@Composable
inline fun Column(
    modifier: Modifier = Modifier,
    verticalArrangement: Arrangement.Vertical = Arrangement.Top,
    horizontalAlignment: Alignment.Horizontal = Alignment.Start,
    content: @Composable ColumnScope.() -> Unit
) {
   
    val measurePolicy = columnMeasurePolicy(verticalArrangement, horizontalAlignment)
    Layout(
        content = {
    ColumnScopeInstance.content() },
        measurePolicy = measurePolicy,
        modifier = modifier
    )
}

所以在上面的例子中，最外层的 Column 组件嵌套了第二个 Column 组件，而第二个 Column 组件嵌套了第三个 Column 组件，由于inline函数的特性，最终所有 Column 组件内部的组件都会被直接在编译期插入到最外层中。所以第三个 Column 组件中读取 update1 的 Text 实际上相当于是处在最外层中。因此当 update1 发生变化时，整个最外层都会重组，因为它们属于同一个重组作用域。

同样的，Row 组件也是内联的。因为这两个组件是在开发当中是会高频使用的组件，所以我们要尤其注意这一点。如果我们不想某个状态值导致整个组件都重组，换句话说，如果我们想最大程度的做到状态隔离，缩小重组作用域，那么最好使用非 inline 的组件，例如 Surface 组件等。

隔离重组作用域

上面提到， inline 组件会将重组作用域暴露给调用者，进而导致调用者的重组作用域被放大，子组件发生重组时父组件也受到了牵连。但是，假如我们的业务代码中已经大量的应用了 Column 或 Row 这样的内联组件，或者我们此时想提升一下页面渲染的性能，想要追求极致的用户体验，我们该怎么办呢？换句话说，就是 如何隔离重组作用域？ 其实很简单，说出来你可能不信：既然 inline 的不行，那么改成 非 inline 的不就可以了嘛。

比如上面的例子，我们可以将 Column 组件换成一个自定义的 Column，我们只需要简单地在外层包装一个 Composable 函数透传 content 即可。例如像下面这样：

@Composable
fun RandomColorColumn(content: @Composable () -> Unit) {
    
    Column(
        modifier = Modifier
            .padding(4.dp)
            .shadow(1.dp, shape = CutCornerShape(topEnd = 8.dp))
            .background(getRandomColor())
            .padding(4.dp)
    ) {
    
        content()
    }
}

然后我们只需将上面例子中的 Column 全部换成这个 RandomColorColumn ，而其他部分的代码基本不动：

@Composable
fun Sample() {
   
    RandomColorColumn {
   
        var update1 by remember {
    mutableStateOf(0) } 
        Text("Text in outer Column", color = Color.White, modifier = Modifier.background(getRandomColor()))
        Button(
            modifier = Modifier.fillMaxWidth(),
            colors = ButtonDefaults.buttonColors(backgroundColor = getRandomColor()),
            onClick = {
    update1++ },
            shape = RoundedCornerShape(5.dp)
        ) {
    
            Text(
                text = "Text in Button1 read update1: $update1",
                textAlign = TextAlign.Center,
                color = Color.White,
                modifier = Modifier.background(getRandomColor())
            )
        }

        RandomColorColumn {
    
            var update2 by remember {
    mutableStateOf(0) }
            Button(
                modifier = Modifier.fillMaxWidth(),
                colors = ButtonDefaults.buttonColors(backgroundColor = getRandomColor()),
                onClick = {
    update2++ },
                shape = RoundedCornerShape(5.dp)
            ) {
    
                Text(
                    text = "Text in Button2 read update2: $update2",
                    textAlign = TextAlign.Center,
                    color = Color.White,
                    modifier = Modifier.background(getRandomColor())
                )
            }
            RandomColorColumn {
      
                Text(
                    text = "🔥 Text in Inner Column read update1: $update1",
                    textAlign = TextAlign.Center,
                    color = Color.White,
                    modifier = Modifier.background(getRandomColor())
                )
            }
        } 
    }
}

效果：

在这里插入图片描述

现在，事情就会变得跟我们预期的那样：当疯狂点击 Button 1 时，只有 Button 1 中的读取 update1 的 Text 以及内部嵌套 RandomColorColumn 中读取 update1 的 Text 组件会发生重组，而不是影响所有整个组件。

也许有人会问：这相比原来直接使用 Column，你又多了嵌套一层，不会影响性能吗？答案是：并不会。原因主要有两点：

之前在 Jetpack Compose中的绘制流程和自定义布局中提到过，Compose 中不允许被多次测量，每个子元素只允许被测量一次，因此并不会因为嵌套层级的增加而导致测量次数的指数爆炸问题，正所谓 “一时嵌套一时爽，一直嵌套一直爽”。
实际上 Compose 编译器会对 Composable 函数施加一些 “魔法”，而 Compose runtime 会持有对这些 Composable 函数的引用，它们可能在运行时以任意顺序被重新执行、并行执行（可能多线程）、甚至被跳过执行，所以它们并不像我们传统意义上的标准函数调用堆栈那样，调用顺序也不会跟我们代码书写的那样按照先后顺序一层一层的往下调用再返回。这一点在 Jetpack Compose 深入探索系列一：Composable 函数中有介绍过，如果你感兴趣的话可以自行了解。

当然嵌套多了的话，也不能说完全没有影响，至少会增加 Compose 编译器的编译时间成本，还有就是最终生成的DEX包可能会大一些。

另外，Jetpack Compose 这个框架本身已经极为优秀了，正常情况下也不会出现太大的性能问题，一般也不需要这么做。只有在你想要鸡蛋里挑骨头、追求极致性能体验的情况下，才需要十分小心的留意你所使用的 Composable 组件是否是 inline 的。

重组作用域内不读取任何参数的组件不会被重组

这里表达的意思是某个组件不从外部接受参数，当我们定义一个组件时，可以在组件内部维护一些状态值，也有可能通过状态提升，将一些状态作为参数暴露出来，交给其公共父组件来管理。但是在父组件中，一旦发生重组，它只会影响那些会为其传递参数的子组件，如果某个子组件不从父组件接受任何参数，那么它在重组中保持不变（从父组件的视角）。这貌似跟本文列出的第一点有点重复，但是我还是想列出来单独说一下。

我们再利用一下本文最开头的例子进行一下修改：

@Composable
fun Sample() {
   
    Column(
        modifier = Modifier
            .padding(4.dp)
            .shadow(1.dp, shape = CutCornerShape(topEnd = 8.dp))
            .background(getRandomColor())
            .padding(4.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
   
        var counter by remember {
    mutableStateOf(0) }
        Text("Text1 Read counter: $counter", color = Color.White, modifier = Modifier.background(getRandomColor()))
        Button(
            modifier = Modifier.fillMaxWidth(),
            colors = ButtonDefaults.buttonColors

最低0.47元/天解锁文章

川峰

关注

4
点赞
踩
11

收藏

觉得还不错? 一键收藏
打赏
1
评论
Jetpack Compose 中的重组作用域和性能优化

标准版本 offset() 在每次偏移量发生改变时，会重新创建 Modifier 实例（hashCode不停变化证实了这一点），当 Modifier 实例发生变化时，组合树会先删除旧的，然后再添加一个新的 Modifier 实例。组合树的变化会导致重组的发生，因此如果偏移量频繁变化，重组就会频繁的发生，而每次重组都有可能触发组合->布局->绘制这三个阶段，这非常要命。而 lambda 版本 offset{} 的优势是， Modifier 实例不会改变（hashCode保持不变证实了这一点），Compose
复制链接

扫一扫