microthreads

Microthreads are a concurrency construct consisting of a large number of lightweight threads managed at the user level rather than by the operating system. Each microthread represents a separate flow of control with its own call stack, but the total memory footprint is small compared with native OS threads. Microthreads enable concurrent execution of many tasks within a single process.

They are typically scheduled by a user-space scheduler or runtime, which can be cooperative (tasks yield explicitly) or preemptive (the scheduler interrupts). They may be stackful, with separate call stacks for each microthread, or stackless, where continuation information is stored in heap-allocated structures. Context switches between microthreads are generally cheaper than kernel threads because no kernel-mode context switch is required.

Common use cases include high-concurrency servers, event-driven networking, simulations, and applications that must manage thousands or millions of lightweight tasks. They are implemented in various forms, including coroutine libraries, green-thread implementations, and certain actor-model frameworks.

Advantages include reduced memory overhead per task, faster creation and switching, and the ability to scale concurrency beyond the number of hardware threads. Disadvantages include potential programming complexity, the need for non-blocking I/O or careful integration with blocking operations, and weaker isolation between tasks compared with OS threads.

The term appears in discussions of coroutines and green threads; practical implementations include protothreads, coroutine libraries in several languages, and runtime systems that use lightweight scheduling within a single OS thread or process.