Green Threads

Introduction

Green threads are threads that are managed entirely in user space by a runtime library or virtual machine (VM), rather than being scheduled and managed by the operating system’s native thread scheduler. They are called “green” because of their early use in the Green Project, the precursor to Java’s first virtual machine.

In contrast to native (OS) threads, which rely on the kernel for creation, scheduling, and management, green threads provide a lightweight and efficient form of concurrency that offers fine-grained control and cross-platform consistency, but at the cost of some parallelism and integration limitations.

What Are Green Threads?

Green threads are user-level threads. Unlike kernel threads, they:

• Are scheduled by a user-space library or runtime, not the OS
• Can be multiplexed over a single native thread
• Don’t inherently take advantage of multiple CPU cores
• Are cooperatively or preemptively scheduled by the runtime

Key Characteristics

How Green Threads Work

Imagine a single OS thread running an event loop that:

1. Picks a green thread from a queue
2. Executes it for a limited slice of time or until it yields
3. Switches to the next green thread

This model allows many lightweight green threads to coexist efficiently within a single native thread.

Scheduling Models

• Cooperative Scheduling: Green threads must yield voluntarily.
• Preemptive Scheduling: Runtime forcibly swaps execution, often with signals or timers.

Advantages of Green Threads

Disadvantages of Green Threads

Green Threads vs Coroutines vs Fibers

Programming Language Support

Java (Historical)

• Java Green Threads used in early versions (1.0) on Solaris.
• Deprecated in favor of native threads for better performance and integration.

Go

• Uses goroutines, which are similar to green threads but backed by a work-stealing scheduler that dynamically maps goroutines to OS threads.
• Goroutines are not true green threads, but conceptually similar.

go func() {
    fmt.Println("I run concurrently!")
}()

Python (Greenlet, gevent)

• greenlet allows lightweight pseudo-threads.
• gevent patches standard libraries to use non-blocking IO with greenlets.

import gevent

def task(n):
    print(f"Task {n} started")
    gevent.sleep(1)
    print(f"Task {n} ended")

gevent.joinall([
    gevent.spawn(task, 1),
    gevent.spawn(task, 2)
])

Erlang / Elixir

• Actor-based model uses lightweight processes scheduled by the BEAM VM.
• These processes are essentially green threads, designed for fault isolation and concurrency.

Rust

• Uses libraries like Tokio and async-std for asynchronous tasks.
• Rust tasks run as green threads managed by the async runtime.

Ruby (Fibers)

• Fibers are cooperative green threads used in concurrency frameworks like Async and Falcon.

Green Threads in Virtual Machines

JVM

• Early JVMs used green threads.
• Modern JVMs use native threads due to better performance on multicore CPUs.

Project Loom (Java)

• Reintroduces green-thread-like “virtual threads”.
• Aims to simplify high-concurrency server applications.

Thread.startVirtualThread(() -> {
    System.out.println("Running in a virtual thread!");
});

Green Thread Scheduling in Practice

Cooperative Example

def task():
    while True:
        do_work()
        yield_control()

Here, the thread must explicitly yield to allow others to run.

Preemptive Example (Simulated)

In some runtimes, a timer interrupt can force a context switch:

// Pseudo-code example
while (running) {
    check_timer();
    if (time_exceeded) switch_to_next_thread();
}

Blocking IO and Green Threads

Blocking system calls are incompatible with pure green-thread models:

• If a green thread performs a blocking read(), the entire green thread system halts.
• Solutions:
  • Patch blocking functions (e.g., gevent in Python)
  • Hybrid model: Combine green threads with OS threads
  • Async runtimes: Use non-blocking IO with epoll/select (Go, Node.js)

Use Cases

Performance Considerations

Modern Trend: Hybrid Scheduling

Languages like Go, Erlang, and Rust combine:

• Green threads for concurrency abstraction
• Native threads for parallelism on multiple cores

This allows millions of goroutines/processes/tasks to be run in parallel across CPU cores efficiently.

Conclusion

Green threads offer a powerful and efficient model for concurrency—especially in IO-bound and massively concurrent applications. By avoiding the overhead of OS threads, they provide fast, portable, and scalable abstractions for modern runtimes.

Although they don’t provide true parallelism on their own, many modern platforms combine green-thread scheduling with OS-level threading to balance developer ergonomics and hardware efficiency. As multi-core CPUs become ubiquitous and demand for concurrency rises, green threads (and their modern variants like goroutines or virtual threads) continue to evolve as a foundational tool in concurrent programming.

Related Keywords

• Asynchronous Programming
• BEAM Virtual Machine
• Cooperative Scheduling
• Coroutine
• Fiber
• Gevent
• Goroutine
• Lightweight Thread
• Project Loom
• Thread Scheduler
• Tokio Runtime
• User-Level Thread
• Virtual Thread
• Yield Instruction