Implement Green Threads: Cooperatively Scheduled User-Space Threads

User-Space Scheduling

Green threads are cooperatively scheduled coroutines living entirely in userspace. No kernel clone(), no preemption timer: each thread yields explicitly. Languages like early Ruby and Go prototypes used this model before OS threads matured.

Stack and Control Transfer

Each green thread needs:

• Private stack: fixed buffer or mmap'd region
• Saved PC/SP: stored when yielding
• Scheduler loop: picks next runnable thread

For example, three threads printing A, B, C with round-robin yields produce ABCABC... only if every thread calls yield() before looping again; forget one yield and the others starve.

cCopy
Loading…

Why This Matters in Production

Go's goroutine runtime, Ruby's Fiber, and pre-1.5 Java's green threads all started from exactly this design: cooperative user-space stacks switched with saved register state instead of kernel involvement. The single-kernel-thread limitation you'll hit here is precisely why early Java green threads were dropped in favor of native threads once multi-core CPUs became common in the early 2000s.

Debugging Checklist

Before you call the implementation done, walk failure modes on purpose. Test empty structures, single-element edge cases, maximum concurrency, and errno paths that must not crash the program. OS code usually fails in production when happy-path tests pass but invariants break under contention or memory pressure.

Implementation Notes

Keep structures small and name fields after kernel counterparts when possible. That lets you read man pages and kernel source side by side while you work. Print observable events during development; remove noisy logs once tests pass reliably.

For This Exercise

You will implement thread creation, cooperative yield(), and a scheduler dispatch loop. Building the stack switch yourself shows why modern runtimes moved to preemptive kernel threads for CPU-bound work.