I have a suspend function that looks something like:

suspend fun foo() {
    collection.forEach { element -> 
        withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
           // Some long running task processing 'element'
        }
    }
}

I'm wondering what would be the simplest way to parallelize the long running tasks (each element would be processed in parallel) I think this is what

async

might be for? It's just not something I've used so far, and I'm not sure what the syntax is..

Yes, you can use `async`:

suspend fun foo(list: List<String>) {
    withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
        coroutineScope {
            val futures = list.map {
                async { it.uppercase() /* heavy computation here */ }
            }
            val results = futures.awaitAll()
        }
    }
}

Thanks. It looks like

suspend fun foo(collection: List<Bar>) {
    collection.map { element -> 
        withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
            async {
               // Some long running task processing 'element'
            }
        }
    }.awaitAll()
}

Might be sufficient (no need to use an additional scope?)

ah yes of course,

withContext

has coroutineScope as well.

The actual implementation is a bit more complicated, so perhaps there's a mistake, but it seems this code still executes sequentially

awaitAll should definitely make it so it runs concurrently

I wonder if it's because I have a few more

withContext{}

inside the async (I'm trying to get back on the main thread to post messages to the UI)

Well the main thread is just that, one thread, so it will do its parts synchronously

suspend fun foo(collection: List<Bar>) {
    collection.map { element -> 
        withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
            async {
               print("start of iteration ($element)")
               doSomeStuff()
               withContext(Dispatchers.Main) {
                   listener.notify()
               }
               doMoreStuff()
               print("end of iteration ($element)")
            }
        }
    }.awaitAll()
}

This prints something like "start of iteration (element 1)" "end of iteration (element 1)" "start of iteration (element 2)" "end of iteration (element 2)"

Yeah I think you want

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

instead

Oh man, this gets confusing

I think this is more akin to what you need:

suspend fun foo(collection: List<Bar>) {
    coroutineScope {
        collection.map { element ->
            async(<http://Dispatchers.IO|Dispatchers.IO>) {
                print("start of iteration ($element)")
                doSomeStuff()
                withContext(Dispatchers.Main) {
                }
                doMoreStuff()
                withContext(Dispatchers.Main) {
                }
                doMoreStuff()
                withContext(Dispatchers.Main) {
                }
                print("end of iteration ($element)")
            }
        }.awaitAll()
    }
}

suspend fun foo(collection: List<Bar>) {
    collection.map { element -> 
        withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
            async {

Should be

suspend fun foo(collection: List<Bar>) {
    withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
        collection.map { element -> 
            async {

If you don’t need results from the coroutines, use

launch

instead of

async

and

join

instead of

await

.

Ok, thanks