compose之mutableStateListOf

mutableStateListOf 返回一个可感知状态变化的MutableList

通常的State只能用来值改变的场景，对于List数据，List引用不变，往内部添加数据这个场景是无法感知到状态变化的，除非我们将List拷贝一份再重新赋值，如下代码

val a = mutableStateOf(mutableListOf(1,2,3)) // a声明为这样
a.value = a.value.toMutableList().apply { add(4} } // a可以感知到状态变化

这样每次赋值就面临拷贝，不是很好，因此这里我们推荐使用mutableStateListOf，构建一个可以感知内部数据变化的List

其实mutableStateListOf内部的实现为了保证不变性，仍然是拷贝元素，只不过它用了更加高效的实现，比我们单纯用toMutableList要高效得多

原理分析

class SnapshotStateList<T> : MutableList<T>, StateObject {
    override var firstStateRecord: StateRecord =
        StateListStateRecord<T>(persistentListOf())
        private set
     ...
}

首先SnapshotStateList继承了MutableList，意味着我们可以以操作MutableList的方式操作SnapshotStateList,同时它又继承了StateObject,代表这个List是一个具有状态感知能力的List,

内部的firstStateRecord形成了一个链表，链表持有一个PersistentList<T>的数据，那么是不是说每次新插入都是建立一个新的节点，新的节点持有新的PersistentList<T>呢？

答案是如果在一次快照的过程中多次操作数据，那么操作的是同一个节点，如果是不同的快照操作，那么会先新建一个节点.

分析内部代码发现，添加数据和删除数据的api，最终都会调用到conditionalUpdate

这个方法的逻辑如下

1. 加锁获取当前头节点的状态，头节点始终维护的是最终的状态，加锁是因为状态是可以多线程的环境下修改的

   1. 当前节点修改数
   2. 当前节点列表

                                   var oldList: PersistentList<T>? = null
                   var currentModification = 0
                   synchronized(sync) {
                       val current = withCurrent { this }
                       currentModification = current.modification
                       oldList = current.list
                   }
   
   

2. 将当前节点PersistentList调用更新的block,产生新的PersistentList

                                   val newList = block(oldList!!)
                   if (newList == oldList) {
                       result = false
                       break
                   }
   
   

3. 加锁，获取一个可写的节点，如果快照版本不同，这里会产生一个新节点，注意这里由于锁是分段的，可能多线程同时更新状态，因此这里比较了下当前节点的modification和老的list的modification是否相同，如果相同的话，将新产生的list赋值给当前节点，同时通知外部写发生了,通知的方法在writable中，如果不同，说明发生了并发的修改，重新执行1，这里的3个步骤的操作都是在while循环中的

   if (synchronized(sync) {
                       writable {
                           if (modification == currentModification) {
                               list = newList
                               modification++
                               true
                           } else false
                       }
                   }
                   ) {
                       result = true
                       break
                   }
   
   

看到这里，发现这里依旧是每次产生新的PersistentList,PersistentList必须保证是轻量的，不可覆盖之前的值才能保证这里的操作不会修改之前的值

PersistentList家族的类图如下

Untitled.png

调用persistentListOf()返回的是SmallPersistentVector,以add方法为例，分析下SmallPersistentVector是如何实现的

// 可以看到在数组大小小于MAX_BUFFER_SIZE(32)，一直是通过拷贝切换的
override fun add(element: E): PersistentList<E> {
        if (size < MAX_BUFFER_SIZE) {
            val newBuffer = buffer.copyOf(size + 1)
            newBuffer[size] = element
            return SmallPersistentVector(newBuffer)
        }
        val tail = presizedBufferWith(element)
        return PersistentVector(buffer, tail, size + 1, 0)
    }

PersistentVector代码分析看上去是由链表加上二级指针的方式去管理buffer,但两者核心都是一个不变的数据结构，

通常我们外部在使用list数据的地方是将list的数据变换为某种ui类型，因此每次数据改变，发生重组时，整体将list数据变换的逻辑都会重新执行

代码分析完成之后，看一个有趣的事情，

mutableStateListOf(mutableStateListOf(a),mutableStateListOf(b))

嵌套mutableStateListOf可行吗？看上去可行，并且内部数据的更新可以独立进行！因为每一个都是单独的mutableStateListOf,在内部的更新可以不用扩散到外部