Hey all, I think I understand coroutines pretty well, but when I think deeper about them, maybe not so much. 😄 I have a question: what exactly happens when blocking code is called from within a suspending function, e.g.

suspend fun foo() =
  withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
    blockingCall()
}

I think this code is handled by a thread from the thread pool that is shared with the Default dispatchers pool, which means that if this suspending function was called from another thread, that thread can now be used for something else, correct? But if this code is reached from another suspending function already executing on that Dispatcher or the default dispatcher, I guess it will try to not switch to another thread? And the thread in the pool that is performing the blocking code is blocked I think. If there are by default 64 threads in that pool, does that mean that for instance in a microservice with a REST controller with suspending functions, only 64 requests can be handled in parallel?

in a microservice with a REST controller with suspending functions, only 64 requests can be handled in parallel

Yes if you're using

<http://Dispatchers.IO|Dispatchers.IO>

directly. The recommended way to handle such tasks is to use a separate view of

<http://Dispatchers.IO|Dispatchers.IO>

that has as many threads as you'd like. Please see https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-dispatchers/-i-o.html

Yes I think so, the only thing remaining is if this function actually gets suspended, what exactly happens. Who decides whether to suspend execution. There is a blocking call waiting to be executed so does that call get paused ?

No one can ever decide for the function that it should suspend. If there is a suspending call in the function, it may suspend, otherwise it won't.

Okay so if no code inside calls yield it might not actually suspend ever?

Not just

yield

but also

delay

,

Mutex::lock

,

Channel::receive

,

suspendCancellableCoroutine

, and so on, and so on. There is a plethora of suspending functions. The point is, they have to be explicitly called for a suspension to happen.

Okay I think I understand now, thanks for your help