Coroutine – Kotlin

A coroutine is a programming construct that allows a function to suspend its execution and resume it later, enabling cooperative multitasking and asynchronous programming

Key Characteristics of Coroutines

Cooperative Multitasking:

Coroutines don’t preemptively switch between tasks; they voluntarily yield control (suspend) to allow other tasks to run.

Non-Blocking Operations:

This cooperative nature enables coroutines to perform tasks without blocking the main thread or other operations, making them suitable for UI-related tasks and I/O operations.

State Preservation:

Coroutines maintain their state between suspensions, allowing them to resume where they left off.

Suspension and Resumption:

Coroutines use special keywords or mechanisms (like await in Python or yield in Unity) to suspend their execution and resume later when needed.

Benefits of Using Coroutines

Simplified Async Programming:

Coroutines provide a cleaner and more readable way to handle asynchronous operations compared to traditional callbacks or promises.

Improved Code Structure:

Coroutines can help organize complex asynchronous logic, making it easier to understand and maintain.

Resource Efficiency:

Coroutines are lightweight and don’t require the overhead of creating and managing multiple threads.

Concurrency Without Threads:

In some cases, coroutines can provide the illusion of concurrency without the need for actual threads, improving efficiency.

Examples

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Main starts: ${Thread.currentThread().name}")

    // Launching a coroutine
    val job = launch {
        delay(1000) // Non-blocking delay (suspends coroutine)
        println("Coroutine says hello from: ${Thread.currentThread().name}")
    }

    println("Main continues...")
    job.join() // Wait for the coroutine to finish

    println("Main ends: ${Thread.currentThread().name}")
}