Simple question... will corotuines launched in a dispatcher that's backed by a thread pool implicitly be parallelized? Eg.

suspend fun foo() = withContext(Dispatchers.Default) {
    for (1..100) {
        async { ... }
    }
}

Will that be bound to a single thread or will is try to spread the workload?

Yup, this is the way to parallelize it (

Default

is backed by a thread pool of more than one thread), but i don’t think the exact number of parallel threads is guaranteed.

cool. Thanks 🙂

This is documented in the kdoc on `Dispatchers.Default`:

It is backed by a shared pool of threads on JVM. By default, the maximal level of parallelism used by this dispatcher is equal to the number of CPU cores, but is at least two. Level of parallelism X guarantees that no more than X tasks can be executed in this dispatcher in parallel.

On JS, there are no threads, and this dispatcher is just backed by the JS event loop, which is not parallelized.

sure, that makes sense

On native, there's only one thread for now because of different concurrency model

That's changing though, right?

Not yet as far as I know.

Is this defunct then? https://github.com/Kotlin/kotlinx.coroutines/blob/native-mt/kotlin-native-sharing.md

Quoting from that very same page:

A Default dispatcher on Kotlin/Native contains a single background thread

gotcha. I figured that was going to be temporary but maybe not?

It's as written after what I quoted on that very same page.

ooof lol. Thanks for the insight though!