35

Green Threads have been implemented with Java 1.1 and dropped in subsequent Java versions, according to https://en.wikipedia.org/wiki/Green_thread.

Java 19 introduced Virtual Threads as a preview feature. https://openjdk.org/jeps/425

Both threads seem to work in User Space and not in Kernel Space as Javas Native Threads do.

What's the difference between them, and are the previous limitations of Green Threads omitted with the new Virtual Threads?

Reg
  • 10,717
  • 6
  • 37
  • 54
cynox
  • 461
  • 4
  • 6

2 Answers2

40

Short Answer:

Green Threads had an N:1 mapping with OS Threads. All the Green Threads ran on a single OS Thread. With Virtual Threads, multiple virtual threads can run on multiple native threads (n:m mapping)

A bit more details from the JEP 425

  • Java's green threads all shared one OS thread (M:1 scheduling) and were eventually outperformed by platform threads (Java's Native Threads) implemented as wrappers for OS threads (1:1 scheduling)

  • Virtual threads employ M:N scheduling, where a large number (M) of virtual threads is scheduled to run on a smaller number (N) of OS threads.

Just a small overview

Thread Type Description Java Thread Type (M) : Native Threads(N)
Platform Threads A wrapper for OS Threads. 1:1
Green Threads Runs multiple "Green Threads" on a single OS Thread. M:1
Virtual Threads Runs multiple Virtual Threads on Multiple OS threads M:N (M > N)

Full Quote from JEP

Virtual threads are a lightweight implementation of threads that is provided by the JDK rather than the OS. They are a form of user-mode threads, which have been successful in other multithreaded languages (e.g., goroutines in Go and processes in Erlang). User-mode threads even featured as so-called "green threads" in early versions of Java, when OS threads were not yet mature and widespread. However, Java's green threads all shared one OS thread (M:1 scheduling) and were eventually outperformed by platform threads, implemented as wrappers for OS threads (1:1 scheduling). Virtual threads employ M:N scheduling, where a large number (M) of virtual threads is scheduled to run on a smaller number (N) of OS threads.

Reg
  • 10,717
  • 6
  • 37
  • 54
  • great post, thanks! I'm however quite confused about the mapping between `Thread` instances and JVM threads: is a JVM created right when a `Thread` object is created or only when `start()` method is called? I've just posted a [question about it](https://stackoverflow.com/questions/76729903/relation-between-jvm-threads-and-thread-instances): it would be super awesome if you could help :) Many thanks!! – morgwai Jul 20 '23 at 12:36
0

Java's green threads all shared one OS thread (M:1 scheduling) and were eventually outperformed by platform threads (Java's Native Threads) implemented as wrappers for OS threads (1:1 scheduling) Virtual threads employ M:N scheduling, where a large number (M) of virtual threads is scheduled to run on a smaller number (N) of OS threads.

Tejas Baviskar
  • 1
  • 1