What is a coroutine in Kotlin and how does it work?

A coroutine in Kotlin is a lightweight unit of execution that allows writing asynchronous, non-blocking code in a more readable and sequential manner. It is similar to a thread but much lighter and can be easily created in large numbers.

Main components and principles:

• Suspend Functions: Functions marked with the suspend keyword can suspend their execution without blocking the thread they run on. When a suspended function completes its "waiting" operation (e.g., a network request), it can resume execution from where it was suspended.
• Context (Coroutine context): A set of elements that control the behavior of a coroutine. The context includes:
  • Job: A descriptor for the coroutine that allows managing its lifecycle (cancellation, waiting for completion).
  • CoroutineDispatcher: Determines the thread(s) on which the coroutine will run. It allows switching between threads.
  • CoroutineName: An optional name for debugging.
  • CoroutineExceptionHandler: Handles unhandled exceptions.
• Builders: Functions that start coroutine execution:
  • launch: Starts a new coroutine without returning a result. It returns a Job.
  • async: Starts a new coroutine that returns a result (Deferred). The result is obtained via .await().
  • runBlocking: A blocking builder used mainly for testing or integrating with blocking code.

How it works under the hood:

Coroutines do not create separate threads for each task. Instead, when a suspend function is suspended, the compiler generates code that saves the current state of computations. When the result is available, the coroutine resumes on one of the threads managed by the CoroutineDispatcher. This is achieved by transforming suspend functions into asynchronous calls with continuations, allowing a single thread to execute many coroutines, switching between them during suspension.

Example:

import kotlinx.coroutines.*

fun main() = runBlocking { // Blocks the current thread until the coroutine inside runBlocking completes
    println("First")

    launch { // Launches a new coroutine in the background
        delay(1000L) // Non-blocking delay for 1 second
        println("After delay")
    }

    println("Then") // This line executes before the launch coroutine completes
}

The output of this code will be:

First
Then
After delay

This demonstrates the non-blocking nature of launch and delay.