Green thread

In Java 1.1, green threads were the only threading model used by the Java virtual machine (JVM),[8] at least on Solaris. As green threads have some limitations compared to native threads, subsequent Java versions dropped them in favor of native threads.[9][10]

An exception to this is the Squawk virtual machine, which is a mixture between an operating system for low-power devices and a Java virtual machine. It uses green threads to minimize the use of native code, and to support migrating its isolates.

Kilim[11][12] and Quasar[13][14] are open-source projects which implement green threads on later versions of the JVM by modifying the Java bytecode produced by the Java compiler (Quasar also supports Kotlin and Clojure).

There are some other programming languages that implement equivalents of green threads instead of native threads. Examples:

• Chicken Scheme uses lightweight user-level threads based on first-class continuations[15]
• .NET does not use green threads. The .NET team has experimented with green threads and concluded that introducing them to .NET is not worth the effort, compared to improving its async/await implementation.[16]
• Common Lisp[17]
• CPython with greenlet, eventlet and gevent, PyPy[18]
• Crystal offers fibers[19]
• D offers fibers, used for asynchronous I/O[20]
• Dyalog APL terms them threads[21]
• Erlang[22]
• Go[23]
• Haskell[23]
• Julia uses green threads for its Tasks.
• Limbo[24]
• Lua uses coroutines for concurrency. Lua 5.2 also offers true C coroutine semantics through the functions lua_yieldk, lua_callk, and lua_pcallk. The CoCo extension allows true C coroutine semantics for Lua 5.1.
• Nim provides asynchronous I/O and coroutines
• OCaml, since version 5.0, supports green threads through the Domainslib.Task module
• occam, which prefers the term process instead of thread due to its origins in communicating sequential processes
• Perl supports green threads through coroutines
• PHP supports green threads through fibers and coroutines
• Ruby before version 1.9[25]
• Racket (native threads are also available through Places[26])
• Rust runs system threads natively.[27]
• SML/NJ's implementation of Concurrent ML
• Smalltalk (most dialects: Squeak, VisualWorks, GNU Smalltalk, etc.)
• Stackless Python supports either preemptive multitasking or cooperative multitasking through microthreads (termed tasklets).[28]
• Tcl has coroutines and an event loop[29]

The Erlang virtual machine has what might be called green processes – they are like operating system processes (they do not share state like threads do) but are implemented within the Erlang Run Time System (erts). These are sometimes termed green threads, but have significant differences from standard green threads.

In the case of GHC Haskell, a context switch occurs at the first allocation after a configurable timeout. GHC threads are also potentially run on one or more OS threads during their lifetime (there is a many-to-many relationship between GHC threads and OS threads), allowing for parallelism on symmetric multiprocessing machines, while not creating more costly OS threads than needed to run on the available number of cores.

occam is unusual in this list because its original implementation was made for the Transputer, and hence no virtual machine was needed. Later ports to other processors have introduced a virtual machine modeled on the design of the Transputer, an effective choice because of the low overheads involved.

Most Smalltalk virtual machines do not count evaluation steps; however, the VM can still preempt the executing thread on external signals (such as expiring timers, or I/O becoming available). Usually round-robin scheduling is used so that a high-priority process that wakes up regularly will effectively implement time-sharing preemption:

 [
    [(Delay forMilliseconds: 50) wait] repeat
 ] forkAt: Processor highIOPriority

Other implementations, e.g., QKS Smalltalk, are always time-sharing. Unlike most green thread implementations, QKS also supports preventing priority inversion.