是否有螺纹安全的方法来记忆Kotlin序列？

Question

我有一种生成序列的方法：

    fun createFactorSequence(decimalMode: DecimalMode): Sequence<BigDecimal> {
        var sign = BigDecimal.ZERO - BigDecimal.ONE
        return createAllFactorialsSequence()
            .filterIndexed { i, _ -> i % 2 != 0 }
            .map { n ->
                sign = -sign
                sign * BigDecimal.ONE.divide(n, decimalMode)
            }
    }

因为多个调用之间的序列将相同，所以似乎应该可以缓存它（我必须按照当前形式的小数模式来键入，但是可能会有是消除对此需求的方法。

我已经在野外看到了一些代码，这些代码试图实现一个记忆的序列，将基础序列的元素记录到列表中，以便下一个调用不需要重新计算它们。

它们主要沿着这些线路工作（我已经简化了它以假设序列是无限的）：

    fun <T> memoizedSequence(slowSequence: Sequence<T>): Sequence<T> {
        val slowIterator = slowSequence.iterator()
        val cachedEntries = mutableListOf<T>()

        return sequence {
            var index = 0
            while (true) {
                // TODO: Not thread-safe!!
                while (cachedEntries.size < index) {
                    cachedEntries.add(slowIterator.next())
                }

                yield(cachedEntries[index])

                index++
            }
        }
    }

如所评论的那样，问题是这不是线程安全。如果两个线程同时通过，并且每个线程都会从迭代器中获得一个元素，则无法保证条目将以相同的顺序最终进入列表。

但是我不能仅仅使用java同步来解决它，因为库是乘数。

有Kotlin做到这一点吗？

我尝试使用mutex（我什至不确定是否可以接受对Coroutines的依赖），但发现我不允许我致电mutex.withlock从内部序列{}。