Hi all, I was trying to find an easy implementation to launch multiple api calls in an async block but instead of waiting for all of them, just wait for the first n that return, cancelling the others. I know I can do something like

val results = endpoints.map {
            async {
                client.call(it)
            }
        }
results.awaitAll()

but of course that will wait for all the calls to come back, not just the first N. I know I could solve this problem by using channels and subscribe n topics waiting for them, but I was wondering if there is a counterpart with async/await as well? Also, as a side note, one thing I’ve noticed is that if the

client

is blocking (imagine a Thread.sleep) the async is called sequentially and I lose completely the parallelism..what am I doing wrong?

• nothing built in, sorry. you can take inspiration from https://github.com/Kotlin/kotlinx.coroutines/issues/2867 • the dispatcher in

runBlocking

is a single threaded event loop. use another dispatcher to dispatch onto other threads (e.g.

async(<http://Dispatchers.IO|Dispatchers.IO>) { ... }

thanks @ephemient Uli suggested to use select that should probably do the work? as per the runBlocking I guess you are right, I was using a TestCoroutineDispatcher that I was passing to the async block (maybe that’s a single threaded?). I wonder that’s the reason why is sequential given that the client is blocking? Is there any way to wrap a blocking execution within a suspension so even a single threaded should give me concurrency when, for instance, I do a

Thread.sleep

?

yes, TestCoroutineScope is also single threaded. no there isn't, they need to be

delay()

or some other suspend fun

alright so if they don’t suspend but they rather block, they will take the thread no matter what I do, is that correct?

yes, exactly. coroutines can only switch at suspend points which are inserted by the compiler when you call suspend funs

gotcha alright thanks for your help! Do you think that

select

can do the trick on the “first n that completes” ?

(well, that's a bit of a simplification. if the function you call never suspends, the mere act of calling won't suspend either. so you can't just wrap

Thread.sleep

in a suspend fun)

if I use channels, is there a way to cancel all other running coroutines? do you have an example on how to do this with channels? The code I came up with seems much more complex than select

neither channels nor select will automatically cancel all other coroutines

gotcha, is there any snippet you can point me to get an idea?

awesome, will try to play with it

if you use

runInterruptible {}

they'll at least be sent a thread interrupt which should break out of well-behaved Java blocking methods

so I should run the client.call into a

runInterruptible

block then, alright

yep. the coroutine doesn't "notice" that it's been cancelled until the next suspension, but at least with runInterruptible that should happen quickly (as long as they blocking code called within doesn't ignore InterruptedException)

yeah I guess that would be a bug

there's definitely no race-free way to check that

and then remove that from the array and cancel all of them.. makes sense

👍 hope you like the coroutines way of composing these concurrency primitives

oh yeah I love them, it takes a bit of time to get used to it but I guess it’s normal