Kotlin延期的任何等价物

Coroutine

async

返回

Deferred

，这里有延迟执行和wait用法的示例

但是，我们如何才能等待任何一个

不同的
实例完成

简而言之

  // whats the equivalent of CompletableFuture.anyOf(...)?
  // is this how we do it? if so how costly is this?
  select<Unit> {
     deffered1.onAwait {}
     deffered2.onAwait {}
  }

//CompletableFuture.anyOf（…）的等价物是什么？
//我们是这样做的吗？如果是这样的话，成本有多高？
挑选{
不同的1.1等待{}
差分2.1等待{}
}
可能不是最安全的做事方式，但像这样的方式应该可以：

inline suspend fun <T> Iterable<Deferred<T>>.awaitAny(): T {
    var completed: T? = null
    forEachIndexed { index, deferred ->
        deferred.invokeOnCompletion {
            completed = deferred.getCompleted()
            forEachIndexed { index2, deferred2 ->
                if (index != index2) {
                    deferred2.cancel(it)
                }
            }
        }
    }
    forEach {
        try {
            it.await()
        } catch (ignored: JobCancellationException) {
            // ignore
        }
    }
    return completed!!
}

像这样使用select表达式

        val deferred1: Deferred<String?> = GlobalScope.async { getValue1() }
        val deferred2: Deferred<String?> = GlobalScope.async { getValue2() }
        val deferred3: Deferred<String?> = GlobalScope.async { getValue3() }

        val deferredList = listOf(deferred1, deferred2, deferred3)
        val firstCompletedResult = select<String?> {
            deferredList.forEach {
                it.onAwait {}
            }
        }
        
        Log.d(TAG, "firstCompleted: $firstCompletedResult")

val deferred1:Deferred=GlobalScope.async{getValue1（）}
val deferred2:Deferred=GlobalScope.async{getValue2（）}
val deferred3:Deferred=GlobalScope.async{getValue3（）}
val deferredList=listOf（deferred1、deferred2、deferred3）
val firstCompletedResult=选择{
deferredList.forEach{
it.onAwait{}
}
}
Log.d（标记“firstCompleted:$firstCompletedResult”）
对于多样性，提到了我用来解决的
select（）
的替代方案（获取延迟集合中的第一个以非空值完成），即

或者如果你愿意

suspend fun <T> Iterable<Deferred<T>>.awaitAny(): T = map { it::await.asFlow() }.merge().first()

suspend fun Iterable.awaitAny（）：T=map{it:：await.asFlow（）}.merge（）.first（）
< /代码>我也不知道协同程序架构知道这个选择有多贵，但是如果有人能解决这个问题，你会很感激的：）你可以试着跨过它，我在那里得到了很快的反馈。“VACH你不妨考虑一下答案：”问题是我不认为这是一个很好的解决办法。将回调放在每个将来都会产生很多垃圾，本质上就像我用选择器演示的一样（除了选择器更具可读性之外），让我们看看kotlin团队的人是否可以提出更好的建议（如果没有，您就有赏金：）
val firstCompletedResult = deferreds.map { it::await.asFlow() }.merge().first()

suspend fun <T> Iterable<Deferred<T>>.awaitAny(): T = map { it::await.asFlow() }.merge().first()