kotlin协程-在收到超时或消息计数之前阻止线程

对于Kotlin，我希望阻止一个线程，直到从回调MessageBroker接收到n条消息（或超时）

例如-类似于

fun receivedMessages(numberOfMessages: Int, timeout: Long): List<Message> {
receivedMessages: ArrayList<Message>

//subscribe to a queue and get a callback for EACH message on the queue e.g.

//listen until the 'numberOfMessages' have been reveived OR the timeout is reached. e.g.

async - block
{
    messageQueue.setMessageListener
    (message -> {
    receivedMessages.add(message)
    if (receivedMessages.size > numberOfMessages) //break out of the routine
})

    //else - if timeout is reached - break the routine.
}.withTimeout(timeout)


return receviedMessages

fun receivedMessages（numberOfMessages:Int，timeout:Long）：列表{
receivedMessages:ArrayList
//订阅队列并获取队列中每条消息的回调，例如。
//收听，直到收到“numberOfMessages”或达到超时。
异步块
{
messageQueue.setMessageListener
（信息->{
receivedMessages.add（消息）
if（receivedMessages.size>numberOfMessages）//中断例程
})
//否则-如果达到超时-中断例程。
}.withTimeout（超时）
返回已接收的消息

}

---

使用kotlin协同程序最有效的方法是什么？

在对kotlin中的协同程序进行了大量研究之后，我决定简单地使用

倒计时闩锁

并让它倒计时，直到收到消息计数；比如,

private fun listenForMessages(consumer: MessageConsumer,messageCount: Int, 
                              timeout: Long): List {
    val messages = mutableListOf<T>()
    val outerLatch = CountDownLatch(messageCount)
    consumer.setMessageListener({ it ->
        //do something
        outerLatch.countDown()
    }
})
outerLatch.await(timeout)
return messages
}

private fun listenformessage（消费者：MessageConsumer，messageCount:Int，
超时：长）：列表{
val messages=mutableListOf（）
val outerLatch=CountDownLatch（messageCount）
consumer.setMessageListener（{it->
//做点什么
outerLatch.倒计时（）
}
})
outerLatch.await（超时）
返回消息
}

在对Kotlin的协同程序进行了大量研究之后，我决定简单地使用一个

倒计时闩锁

，并让它倒计时，直到收到messageCount；比如,

private fun listenForMessages(consumer: MessageConsumer,messageCount: Int, 
                              timeout: Long): List {
    val messages = mutableListOf<T>()
    val outerLatch = CountDownLatch(messageCount)
    consumer.setMessageListener({ it ->
        //do something
        outerLatch.countDown()
    }
})
outerLatch.await(timeout)
return messages
}

private fun listenformessage（消费者：MessageConsumer，messageCount:Int，
超时：长）：列表{
val messages=mutableListOf（）
val outerLatch=CountDownLatch（messageCount）
consumer.setMessageListener（{it->
//做点什么
outerLatch.倒计时（）
}
})
outerLatch.await（超时）
返回消息
}