Question

我正在尝试在Kotlin中为Iterable和Sequence实施并行实现。我有一个小文件，它包含4个扩展功能，但是第三个给了我一个编译器错误：

suspend fun <T, R> Iterable<T>.parallelMap(block: suspend(T) -> R) =
    coroutineScope { map { async { block(it) } }.map { it.await() } }

suspend fun <T> Iterable<T>.parallelForEach(block: suspend (T) -> Unit) =
    coroutineScope { map { async { block(it) } }.forEach { it.await() } }

suspend fun <T, R> Sequence<T>.parallelMap(block: suspend(T) -> R) =
    coroutineScope { map { async { block(it) } }.map { it.await() } }

suspend fun <T> Sequence<T>.parallelForEach(block: suspend (T) -> Unit) =
    coroutineScope { map { async { block(it) } }.forEach { it.await() } }

编译器返回并说挂起函数只能在挂起函数内部调用。有办法实现吗？

编辑：修复了错误的复制/粘贴

Edit2：我想到了一个实现：

suspend fun <T, R> Sequence<T>.parrallelMap(block: suspend (T) -> R) =
        asIterable().map { coroutineScope { async { block(it) } } }
              .asSequence().map { runBlocking { it.await() } }

我希望这能触发所有挂起的函数并懒洋洋地等待它们。我只是不确定这是否安全，否则可以节省时间。

Answer 1

惰性序列的并行执行的核心语义存在问题。在迭代结果序列之前，您当前的实现不会启动block(it)：

suspend fun <T, R> Sequence<T>.parallelMap(block: suspend(T) -> R) =
    coroutineScope { map { async { block(it) } }.map { it.await() } }

考虑以下示例：

sequenceOf(1, 2, 3).parallelMap { it * it }.forEach { println(it) }

对于此示例，执行顺序为

val p1 = async { 1 * 1 } 
val r1 = p1.await()
println(r1)
val p2 = async { 2 * 2 } 
val r2 = p2.await()
println(r2)
val p3 = async { 3 * 3 } 
val r3 = p3.await()
println(r3)

请注意，映射操作的执行是顺序的，而不是并行的。

编译器告诉您Sequence<T>.map {}的lambda是在调用上下文之外按需执行的（请参阅：在协程之外），因此您不能使用自己的协程目前在。

坦率地说，我不确定一个人如何既可以执行惰性计算又可以并行执行。

如何在Kotlin中实现序列的并行映射

1 个答案: