Introduction

A coroutine is a special function that can pause its execution and resume later, without blocking the thread it runs on. Unlike an ordinary function that runs from start to finish in one go, a coroutine can suspend at a certain point, let other work happen, and then continue exactly where it left off — remembering all its local state.

Real-World Analogy

Why Use Coroutines?

Prerequisites

Core Concepts

Coroutine vs Thread

Coroutines in Python (asyncio)

Python uses async def to declare a coroutine and await to suspend at an awaitable point.

import asyncio

async def fetch_data(name, delay):
    print(f"Start {name}")
    await asyncio.sleep(delay)   # suspension point (non-blocking)
    print(f"Done {name}")
    return f"{name}-result"

async def main():
    # Run two coroutines concurrently on one thread
    results = await asyncio.gather(
        fetch_data("A", 2),
        fetch_data("B", 1),
    )
    print(results)

asyncio.run(main())

Coroutines in Kotlin

Kotlin has first-class coroutine support via the kotlinx.coroutines library and the suspend keyword.

import kotlinx.coroutines.*

suspend fun fetchData(name: String, delay: Long): String {
    println("Start $name")
    delay(delay)              // suspending function
    println("Done $name")
    return "$name-result"
}

fun main() = runBlocking {
    val a = async { fetchData("A", 2000) }
    val b = async { fetchData("B", 1000) }
    println(listOf(a.await(), b.await()))
}

Coroutine-style async in JavaScript

JavaScript uses async/await built on Promises — conceptually the same pause/resume model.

function fetchData(name, delay) {
    return new Promise(resolve => {
        console.log("Start " + name);
        setTimeout(() => {
            console.log("Done " + name);
            resolve(name + "-result");
        }, delay);
    });
}

async function main() {
    const results = await Promise.all([
        fetchData("A", 2000),
        fetchData("B", 1000),
    ]);
    console.log(results);
}

main();

Coroutines in C++20

C++20 introduced coroutines with the keywords co_await, co_yield, and co_return.

#include <coroutine>
#include <iostream>

struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};

Task example() {
    std::cout << "Before suspend\n";
    co_await std::suspend_always{};   // pause here
    std::cout << "After resume\n";
}

How a Coroutine Works Internally

1. The coroutine starts executing like a normal function.
2. At a suspension point (await / yield), it saves its state (local variables, position) into a heap-allocated frame.
3. Control returns to the scheduler / caller.
4. When the awaited result is ready, the scheduler resumes the coroutine from the saved frame.
5. Execution continues until the next suspension point or completion.

Why Coroutines Scale Better

If each thread needs \(M_t\) memory and each coroutine needs \(M_c\) memory (with \(M_c \ll M_t\)), then for \(N\) concurrent tasks the total memory is:

\[ \text{Mem}_{\text{threads}} = N \times M_t \qquad\qquad \text{Mem}_{\text{coroutines}} = N \times M_c \]

Since \(M_c\) is often a few KB versus ~1 MB for a thread, coroutines can handle orders of magnitude more concurrent tasks in the same memory budget.

Types of Coroutines

Best Practices

Common Mistakes

Interview Questions

Quick Revision