* RecordNestedPatternsExample.

* VirtualThreads.

Author: jhon0010

src/main/java/features_versions/nineteen_19/base/RecordNestedPatternsExample.java

@@ -0,0 +1,36 @@
+package features_versions.nineteen_19.base;
+
+/**
+ * Nested Record pattern is a new feature in Java 19
+ */
+public class RecordNestedPatternsExample {
+
+    public static void main(String[] args) {
+
+        printSum(new Total(new Point(10, 5), new Point(2, 3)));
+    }
+
+    /**
+     * Record pattern
+     * @param x
+     * @param y
+     */
+    record Point(int x, int y) {    }
+
+
+    /**
+     * Nested record pattern
+      * @param p1
+     * @param p2
+     */
+    record Total(Point p1, Point p2) {}
+
+
+    static void printSum(Object o) {
+        // record nested pattern
+        if (o instanceof Total(Point(int x,int y),Point(int x2,int y2))) {
+            System.out.println(x + y + x2 + y2);
+        }
+    }
+
+}

src/main/java/features_versions/nineteen_19/base/VirtualThreads.java

@@ -0,0 +1,82 @@
+package features_versions.nineteen_19.base;
+
+import java.time.Duration;
+import java.util.concurrent.Executors;
+import java.util.stream.IntStream;
+
+/**
+ * JEP 425: Virtual Threads (Preview)
+ *
+ * This JEP introduces virtual threads, a lightweight implementation of threads provided by the JDK instead of the OS.
+ * The number of virtual threads can be much larger than the number of OS threads. These virtual threads help increase
+ * the throughput of the concurrent applications.
+ */
+public class VirtualThreads {
+
+    public static void main(String[] args) {
+        usingVirtualThreads();
+        usingNewFixedThreadPool();
+    }
+
+    public static void usingVirtualThreads() {
+
+        long startTime = System.currentTimeMillis();
+        System.out.println(STR."Using virtual threads start time: \{startTime}");
+
+        // finish within 1 second
+        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
+            IntStream.range(0, 10_000).forEach(i -> {
+                executor.submit(() -> {
+                    Thread.sleep(Duration.ofSeconds(1));
+                    return i;
+                });
+            });
+        }
+
+        long endTime = System.currentTimeMillis();
+        System.out.println(STR."Using virtual threads end time: \{endTime}");
+        System.out.println(STR."Using virtual threads duration: \{endTime - startTime}");
+
+    }
+
+    /**
+     * This method uses the newFixedThreadPool to execute the 10_000 tasks.
+     * You probably need to manually stop the process because it takes a long time to finish.
+     */
+    public static void usingNewFixedThreadPool() {
+
+        long startTime = System.currentTimeMillis();
+        System.out.println(STR."Using newFixedThreadPool start time: \{startTime}");
+
+        // 10_000/20 = 500seconds, it takes 8 minutes and 33 seconds to finish it
+        try (var executor = Executors.newFixedThreadPool(20)) {
+            IntStream.range(0, 10_000).forEach(i -> {
+                executor.submit(() -> {
+                    Thread.sleep(Duration.ofSeconds(1));
+                    return i;
+                });
+            });
+        }
+
+        long endTime = System.currentTimeMillis();
+        System.out.println(STR."Using newFixedThreadPool end time: \{endTime}");
+        System.out.println(STR."Using newFixedThreadPool duration: \{endTime - startTime}");
+
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}