启动协程生成器会导致挂起函数在新线程上运行吗？

Question

Started using Kotlin coroutines recently

here is the syntax:

main(){
launch(Dispatchers.Main){
    delay(2000)
    print("inside coroutine")
}
print("outside coroutine")
}

I understand that outside coroutine is printed first and then inside coroutine is printed because delay is a suspend function and it blocks the coroutine only and not the thread itself.

But as the coroutine would need to be executed somewhere else(like on a different thread) for it to know when to resume, how is this taken care of?

It can be any process intense suspend function instead of delay.

Only thing I can't understand is Does the suspend function actually run on a different thread under the hood irrespective of the Dispatcher provided in launch{} builder?

Answer 1

delay() function is run asynchronously under the hood. Other suspend functions would block the thread if run using Dispatchers.Main

Answer 2

suspend functions are designed to block current coroutine, not the thread, it means they should run in background thread. For example delay function blocks coroutine for a given time without blocking a thread and resumes it after a specified time. You can create a suspend function which runs on background thread like the following:

suspend fun someSuspendFun() = withContext(Dispatchers.IO) {
    // do some long running operation
}

Using withContext(Dispatchers.IO) we switch the context of function execution to background thread. withContext function also can return some result.

To call that function we can use a coroutine builder:

someScope.launch(Dispatchers.Main){
    someSuspendFun() // suspends current coroutine without blocking the Main Thread
    print("inside coroutine") // this line will be executed in the Main Thread after `someSuspendFun()` function finish execution.
}