added Java 19 virtual thread examples

Author: wesleyegberto

java-19/Fibonacci.java

@@ -0,0 +1,52 @@
+import java.util.concurrent.Executor;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.net.URI;
+import java.net.http.HttpRequest;
+import java.net.http.HttpClient;
+import java.time.Duration;
+import java.io.IOException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+
+/**
+ * fib of 47 takes ~11s
+ * fib of 49 fakes ~30s
+ */
+public class Fibonacci {
+	public static long fib(int n) {
+		if (n <= 2)
+			return 1;
+		return fib(n - 1) + fib(n - 2);
+	}
+
+	public static CompletableFuture<Long> parallelFib(int n, Executor executor) {
+		CompletableFuture<Long> partOne = CompletableFuture.supplyAsync(() -> fib(n - 1), executor);
+		CompletableFuture<Long> partTwo = CompletableFuture.supplyAsync(() -> fib(n - 2), executor);
+		return partOne.thenCombineAsync(partTwo, (resultOne, resultTwo) -> resultOne + resultTwo, executor);
+	}
+
+	public static CompletableFuture<Long> fibWithRequest(int i, int n, Executor executor) {
+		return CompletableFuture.supplyAsync(() -> fib(n), executor)
+				.thenComposeAsync(result -> {
+					var request = HttpRequest.newBuilder()
+							.GET()
+							.uri(URI.create("https://httpbin.org/delay/5"))
+							.build();
+					var httpClient = HttpClient.newBuilder()
+							.version(HttpClient.Version.HTTP_1_1)
+							.connectTimeout(Duration.ofSeconds(30))
+							.executor(executor)
+							.build();
+					try {
+						System.out.printf("Thread %d - requesting%n", i);
+						return httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString())
+							.thenApplyAsync(resp -> result);
+					} catch (Exception ex) {
+						throw new RuntimeException(ex);
+					}
+				}, executor);
+	}
+}

java-19/README.md

@@ -1,6 +1,6 @@
-# Java 18
+# Java 19
 
-To run each example use: `java --enable-preview --source 18 <FileName.java>`
+To run each example use: `java --enable-preview --source 19 <FileName.java>`
 
 ## Features
 
@@ -12,7 +12,8 @@ To run each example use: `java --enable-preview --source 18 <FileName.java>`
     * definition: guard is the boolean expression, guarded pattern is the case with guard
       * guarded pattern: `case Hero h when h.getCity() == Cities.NEW_YORK`
       * guard: `h.getCity() == Cities.NEW_YORK`
-* Virtual Threads (user-mode threads)
+* Virtual Threads
+  * also called user-mode threads or [fiber](https://en.wikipedia.org/wiki/Fiber_(computer_science))
   * `Virtual threads are lightweight threads that dramatically reduce the effort of writing, maintaining, and observing high-throughput concurrent applications`
   * definitions:
     * virtual thread is an instance of `java.lang.Thread` that is not tied to a particular OS thread, only consumes an OS thread only while it performs calculations on the CPU;
@@ -28,6 +29,7 @@ To run each example use: `java --enable-preview --source 18 <FileName.java>`
   * support thread-local variables and interruption
   * more notes about Project Loom [here](../java-loom/)
   * we can use `Executors.newVirtualThreadPerTaskExecutor` to create virtual threads
+  * [here](platform-thread-vs-virtual-thread.md) is some details about the Platform Thread vs Virtual Thread examples
 
 ## JEPs
 

java-19/StressPlatformThread.java

@@ -0,0 +1,23 @@
+import java.util.concurrent.Executors;
+import java.util.stream.IntStream;
+
+/**
+ * Run: `java --enable-preview --source 19 <FileName.java>`
+ */
+public class StressPlatformThread {
+	public static void main(String[] args) {
+		var executor = Executors.newCachedThreadPool();
+		// WARNING: 10K threads sleeping 500 may restart your computer (save everything before run it!)
+		// IntStream.range(0, 10_000).forEach(i -> {
+		IntStream.range(0, 1_000).forEach(i -> {
+			executor.submit(() -> {
+				System.out.printf("Thread %d - %s%n", i, Thread.currentThread().getName());
+				try {
+					Thread.sleep(500);
+				} catch (InterruptedException e) {
+					System.out.printf("Thread %d - %s interrupted%n", i, Thread.currentThread().getName());
+				}
+			});
+		});
+	}
+}

java-19/StressPlatformThreadWithFibonacci.java

@@ -0,0 +1,22 @@
+import java.util.concurrent.Executors;
+import java.util.stream.IntStream;
+
+/**
+ * Run:
+ * - `javac Fibonacci.java`
+ * - `java --enable-preview --source 19 <FileName.java>`
+ */
+public class StressPlatformThreadWithFibonacci {
+	public static void main(String[] args) {
+		var executor = Executors.newCachedThreadPool();
+
+		IntStream.range(0, 50).forEach(i -> {
+			executor.submit(() -> {
+				Fibonacci.parallelFib(47, executor)
+					.thenAccept(result -> {
+						System.out.printf("Platform Thread %d - %d%n", i, result);
+					});
+			});
+		});
+	}
+}

java-19/StressPlatformThreadWithFibonacciAndRequest.java

@@ -0,0 +1,26 @@
+import java.util.concurrent.Executors;
+import java.util.stream.IntStream;
+
+/**
+ * Run:
+ * - `javac Fibonacci.java`
+ * - `java --enable-preview --source 19 <FileName.java>`
+ */
+public class StressPlatformThreadWithFibonacciAndRequest {
+	public static void main(String[] args) {
+		var executor = Executors.newCachedThreadPool();
+
+		IntStream.range(0, 100).forEach(i -> {
+			executor.submit(() -> {
+				Fibonacci.fibWithRequest(i, 40, executor)
+					.thenAccept(result -> {
+						System.out.printf("Platform Thread %d - %d%n", i, result);
+					})
+					.exceptionally(ex -> {
+						System.out.printf("Platform Thread %d - error: %s%n", i, ex.getMessage());
+						return null;
+					});;
+			});
+		});
+	}
+}

java-19/StressVirtualThread.java

@@ -0,0 +1,28 @@
+import java.util.concurrent.Executors;
+import java.util.stream.IntStream;
+
+/**
+ * Run: `java --enable-preview --source 19 <FileName.java>`
+ */
+public class StressVirtualThread {
+	public static void main(String[] args) {
+		var executor = Executors.newThreadPerTaskExecutor(Thread.ofVirtual().factory());
+
+		IntStream.range(0, 10_000).forEach(i -> {
+			executor.submit(() -> {
+				System.out.printf("VirtualThread %d - %s%n", i, Thread.currentThread().getName());
+				try {
+					Thread.sleep(500);
+				} catch (InterruptedException e) {
+					System.out.printf("VirtualThread %d - %s interrupted%n", i, Thread.currentThread().getName());
+				} finally {
+					System.out.printf("VirtualThread %d - %s woke up%n", i, Thread.currentThread().getName());
+				}
+			});
+		});
+
+		while (!executor.isTerminated()) {
+			;
+		}
+	}
+}

java-19/StressVirtualThreadWithFibonacci.java

@@ -0,0 +1,26 @@
+import java.util.concurrent.Executors;
+import java.util.stream.IntStream;
+
+/**
+ * Run:
+ * - `javac Fibonacci.java`
+ * - `java --enable-preview --source 19 <FileName.java>`
+ */
+public class StressVirtualThreadWithFibonacci {
+	public static void main(String[] args) {
+		var executor = Executors.newThreadPerTaskExecutor(Thread.ofVirtual().factory());
+
+		IntStream.range(0, 50).forEach(i -> {
+			executor.submit(() -> {
+				Fibonacci.parallelFib(47, executor)
+					.thenAccept(result -> {
+						System.out.printf("Virtual Thread %d - %d%n", i, result);
+					});
+			});
+		});
+
+		while (!executor.isTerminated()) {
+			;
+		}
+	}
+}

java-19/StressVirtualThreadWithFibonacciAndRequest.java

@@ -0,0 +1,30 @@
+import java.util.concurrent.Executors;
+import java.util.stream.IntStream;
+
+/**
+ * Run:
+ * - `javac Fibonacci.java`
+ * - `java --enable-preview --source 19 <FileName.java>`
+ */
+public class StressVirtualThreadWithFibonacciAndRequest {
+	public static void main(String[] args) {
+		var executor = Executors.newThreadPerTaskExecutor(Thread.ofVirtual().factory());
+
+		IntStream.range(0, 100).forEach(i -> {
+			executor.submit(() -> {
+				Fibonacci.fibWithRequest(i, 40, executor)
+					.thenAccept(result -> {
+						System.out.printf("Virtual Thread %d - %d%n", i, result);
+					})
+					.exceptionally(ex -> {
+						System.out.printf("Virtual Thread %d - error: %s%n", i, ex.getMessage());
+						return null;
+					});
+			});
+		});
+
+		while (!executor.isTerminated()) {
+			;
+		}
+	}
+}

java-19/img/macos-threads-settings.png

@@ -0,0 +1,116 @@
+# Platform Thread vs Virtual Thread
+
+## Start 10K Threads
+
+The codes in `StressPlatformThread` and `StressVirtualThread` tries to show some different beetween platform and virtual thread using VisualVM to inspect the threads running.
+
+### Platform Thread
+
+The example _tries_ to start 10K [real] threads to sleep for 500ms.
+My Macbook 2015 couldn't handle 4K threads (we default JVM settings), after sometime it started to fail task submit and even GC were unable to run, then my macbook crashed.
+
+My macOS currently has the default settings in maximum num of threads that can be created and threads per process:
+
+![](img/macos-threads-settings.png)
+
+Using 1K threads or changing to sleep for 100ms my macbook didn't crashed, so I could see VisualVM:
+
+**1K Threads Started**
+
+Looking at the Threads tab, we can see (by the scroll size) how many threads was started:
+
+| Monitor | Timeline |
+|---|---|
+| ![](img/platform-thread-count.png) | ![](img/platform-thread-timeline.png) |
+
+**10K sleeping 500ms**
+
+When trying to run 10K threads sleeping for 500ms, I reached the macOS limit and things started to crash.
+
+Before my Macbook restart, I could see:
+
+![](img/platform-thread-500ms-count.png)
+
+And right before restart:
+
+![](img/platform-thread-500ms-error.png)
+
+### Virtual Thread
+
+The example starts 10K virtual threads to sleep for 30s.
+
+The code runs easily as virtual threads is just sleeping, so ins't doing CPU-bound work.
+The JVM just starts them all and puts them aside util they wake up to really use the thread (just print).
+
+Note that the default implementation is using ForkJoinPool to run the virtual threads work.
+
+| Monitor | Timeline |
+|---|---|
+| ![](img/virtual-thread-count.png) | ![](img/virtual-thread-timeline.png) |
+
+## Fibonacci (CPU-bound)
+
+The CPU-bound work I was expecting Virtual Thread version to take more time to execute.
+
+Worth note that the Platform Thread version used more resources (memory and OS threads) which caused more GC pressure.
+
+### Platform Thread
+
+Time taken to run:
+
+```
+933.01s user 3.05s system 681% cpu 2:17.38 total
+```
+
+| Monitor | Timeline |
+|---|---|
+| ![](img/platform-thread-fib-monitor.png) | ![](img/platform-thread-fib-timeline.png) |
+
+### Virtual Thread
+
+Time taken to run:
+
+```
+957.94s user 3.43s system 614% cpu 2:36.55 total
+```
+
+| Monitor | Timeline |
+|---|---|
+| ![](img/virtual-thread-fib-monitor.png) | ![](img/virtual-thread-fib-timeline.png) |
+
+## Fibonacci and HTTP Request (CPU-bound and IO-bound)
+
+100 fibonacci of 40 and request during 5s.
+
+Again, note the resources used in Platform Thread version
+
+Note the different between the memory and thread graphs for Platform and Virtual threads.
+
+**My interpretation:**
+
+The Platform Thread used real thread for each task (100), there were concorrency that caused all the calculation to end together, thus doing all the requesting also together (high slope in memory and thread count graph).
+
+The Virtual Thread version had few real threads (pool with 10 threads), the OS [maybe] gave more time to taks allowing them to finish sooner, thus causing the requestings in small batches (smoothier slope in memory and thread count graph).
+
+### Platform Thread
+
+```
+104.54s user 1.20s system 448% cpu 23.598 total
+```
+
+| Monitor | Timeline |
+|---|---|
+| ![](img/platform-thread-fibreq-monitor.png) | ![](img/platform-thread-fibreq-timeline.png) |
+
+
+### Virtual Thread
+
+Time taken to run:
+
+```
+77.55s user 0.89s system 403% cpu 19.458 total
+```
+
+| Monitor | Timeline |
+|---|---|
+| ![](img/virtual-thread-fibreq-monitor.png) | ![](img/virtual-thread-fibreq-timeline.png) |