What mechanisms in coroutines implement cooperative multitasking?

In coroutines, cooperative multitasking is implemented through the following mechanisms:

• Suspension Points: A coroutine can be "suspended" at certain points (suspension points) without blocking the thread. This occurs when calling suspend functions. During suspension, the thread that was executing the coroutine is free to perform other tasks.

• Dispatchers: Coroutines use dispatchers (Dispatchers) to determine the thread pool on which they will run. A coroutine can be suspended on one thread and resumed on another.

• Continuation: Every time a coroutine is suspended, a Continuation object is created, which holds the state of the coroutine at that moment. When the coroutine resumes, it uses this object to restore its state and continue execution from where it was suspended.

• Cooperation: The developer explicitly indicates suspension points (suspend) in the code. This makes multitasking "cooperative" – the coroutine voluntarily yields control to another coroutine or task at certain points, instead of being forcibly interrupted by the operating system, as in preemptive multitasking of threads.

• Structured Concurrency: Coroutines are bound to a specific scope (CoroutineScope). This allows canceling a group of coroutines simultaneously and guarantees that all child coroutines will complete when the parent scope ends.

// Example suspend function creating a suspension point
suspend fun fetchDataFromNetwork(): String {
    // Simulate a network request
    delay(1000) // This is a suspend function - a suspension point
    return "Data received"
}

fun main() = runBlocking {
    // runBlocking creates a CoroutineScope and blocks the current thread until the coroutine completes
    println("Start")

    launch {
        // Launch a coroutine on another thread (or the same, depending on the dispatcher)
        val data = fetchDataFromNetwork() // The coroutine can be suspended here
        println("Received: $data")
    }

    println("End (main thread is not blocked by fetchDataFromNetwork)")
    // The main thread can perform other tasks while fetchDataFromNetwork is waiting
}