JDK 21: updated readme; added note to indicate which example I've used JDK built from main branch

Author: wesleyegberto

Diff for: java-21/InstanceMainMethodLauncher.java

@@ -1,4 +1,6 @@
 /**
+ * Using JDK manually built from main branch.
+ *
  * To run: `java --enable-preview --source 21 InstanceMainMethodLauncher.java`
  */
 class InstanceMainMethodLauncher {

Diff for: java-21/README.md

@@ -4,20 +4,22 @@ To run each example use: `java --enable-preview --source 21 <FileName.java>`
 
 ## JEPs
 
-* [404](https://openjdk.java.net/jeps/404) - Generational Shenandoah (Experimental)
-* [430](https://openjdk.java.net/jeps/430) - String Templates (Preview)
-* [431](https://openjdk.java.net/jeps/431) - Sequenced Collections
-* [439](https://openjdk.java.net/jeps/439) - Generational ZGC
-* [440](https://openjdk.java.net/jeps/440) - Record Patterns
-* [441](https://openjdk.java.net/jeps/441) - Pattern Matching for switch
+* [404](https://openjdk.org/jeps/404) - Generational Shenandoah (Experimental; Target to drop)
+* [430](https://openjdk.org/jeps/430) - String Templates (Preview)
+* [431](https://openjdk.org/jeps/431) - Sequenced Collections
+* [439](https://openjdk.org/jeps/439) - Generational ZGC
+* [440](https://openjdk.org/jeps/440) - Record Patterns
+* [441](https://openjdk.org/jeps/441) - Pattern Matching for switch
 * [442](https://openjdk.org/jeps/442) - Foreign Function & Memory API (Third Preview)
 * [443](https://openjdk.org/jeps/443) - Unnamed Patterns and Variables (Preview)
 * [444](https://openjdk.org/jeps/444) - Virtual Threads
 * [445](https://openjdk.org/jeps/445) - Unnamed Classes and Instance Main Methods (Preview)
+* [446](https://openjdk.org/jeps/446) - Scoped Values (Preview)
 * [448](https://openjdk.org/jeps/448) - Vector API (Sixth Incubator)
 * [449](https://openjdk.org/jeps/449) - Deprecate the Windows 32-bit x86 Port for Removal
 * [451](https://openjdk.org/jeps/451) - Prepare to Disallow the Dynamic Loading of Agents
 * [452](https://openjdk.org/jeps/452) - Key Encapsulation Mechanism API
+* [453](https://openjdk.org/jeps/453) - Structured Concurrency (Preview)
 
 ## Features
 
@@ -26,6 +28,13 @@ To run each example use: `java --enable-preview --source 21 <FileName.java>`
   * changed to make virtual threads always support thread-local
     * in preview releases was possible to create a virtual thread without thread-local support
   * flag `jdk.traceVirtualThreadLocals` to show the strack trace when a virtual threads sets a value in thread-local variable
+* Scoped values
+  * promoted from incubated to preview feature
+  * moved from pacote `jdk.incubator.concurrent` to `java.util.concurrent`
+* Structured concurrency
+  * promoted from incubated to preview feature
+  * moved from pacote `jdk.incubator.concurrent` to `java.util.concurrent`
+  * changed method `StructuredTaskScope.fork` to return a `Subtask` instanceof of a `Future`
 * Record patterns
   * promotion to standard
   * the main change is remove the support for record pattern in header of an enhanced for loop
@@ -124,6 +133,7 @@ To run each example use: `java --enable-preview --source 21 <FileName.java>`
   * unnamed class:
     * any method declared in a source file without an enclosed class will be considered to be member of an unnamed top-level class
     * the compiler requires an unnamed method to have a valid main method to be launched
+    * we cannot use javadoc tool to generate documation from a unnamed class (doesn't have a accessible API from other class)
     * unnamed class is always final and cannot implement or extends any class other than `Object`
       * is equivalent to the following usage of anonymous class declaration:
       ```java

Diff for: java-21/ScopedValueUsageExample.java

@@ -0,0 +1,61 @@
+import java.util.concurrent.*;
+
+/**
+ * Using JDK manually built from main branch.
+ *
+ * The only change from JDK 20 is the package to import
+ * (we no longer need to use add-module jdk.incubator.concurrent).
+ *
+ * **Not released in the build yet**
+ * Run: `java --source 21 --enable-preview ScopedValueUsageExample.java`
+ */
+public class ScopedValueUsageExample {
+	final static ScopedValue<String> MAIN_SCOPE = ScopedValue.newInstance();
+
+	public static void main(String[] args) {
+		System.out.println("Starting scoped value");
+
+		// we can share a value from here
+		ScopedValue.where(MAIN_SCOPE, "message from main")
+			.run(() -> {
+				var worker = new Worker();
+				worker.execute();
+			});
+		System.out.println("main ending");
+	}
+}
+
+class Worker {
+	final static ScopedValue<String> WORKER_SCOPE = ScopedValue.newInstance();
+
+	public void execute() {
+		// accessing the value from the scope
+		System.out.println("shared value from main: " + ScopedValueUsageExample.MAIN_SCOPE.get());
+
+		// === Nested Scope ===
+		// we can create a nested scope
+		ScopedValue.where(WORKER_SCOPE, "message from worker")
+			.run(() -> {
+				// the outmost scope will still works
+				var messageFromMain = ScopedValueUsageExample.MAIN_SCOPE.get();
+				var messageFromWorker = WORKER_SCOPE.get();
+				System.out.println("shared value to inner scope from main: " + messageFromMain);
+				System.out.println("shared value to inner scope from worker: " + messageFromWorker);
+			});
+
+		// we cannot access it from outside its scope (NoSuchElementException)
+		// var invalidAccess = WORKER_SCOPE.get();
+
+		// === Rebinded Scope Value ===
+		// we can create a new scope that rebinds a new value to the created scope (when using the same variable)
+		ScopedValue.where(ScopedValueUsageExample.MAIN_SCOPE, "message from worker over main")
+			.run(() -> {
+				// the outmost scope will still works
+				var rebindedMessage = ScopedValueUsageExample.MAIN_SCOPE.get();
+				System.out.println("shared value from shadowed scope: " + rebindedMessage);
+			});
+
+		// but the original scope from main will still have its initial value (immutable)
+		System.out.println("shared value from main after all scopes: " + ScopedValueUsageExample.MAIN_SCOPE.get());
+	}
+}

Diff for: java-21/UnnamedClassMainMethodLauncher.java

@@ -1,6 +1,24 @@
 /**
+ * Using JDK manually built from main branch.
+ *
  * To run: `java --enable-preview --source 21 UnnamedClassMainMethodLauncher.java`
  */
 void main() {
 	System.out.println("Hello world from a unnamed class with a main method o/");
 }
+
+/**
+To see the generated class:
+- `javac --enable-preview --source 21 UnnamedClassMainMethodLauncher.java`
+- `javap UnnamedClassMainMethodLauncher`
+
+Output:
+
+```
+Compiled from "UnnamedClassMainMethodLauncher.java"
+final class UnnamedClassMainMethodLauncher {
+  UnnamedClassMainMethodLauncher();
+  void main();
+}
+```
+*/

Diff for: java-21/UnnamedClassWithAllowedMembers.java

@@ -1,4 +1,6 @@
 /**
+ * Using JDK manually built from main branch.
+ *
  * To run: `java --enable-preview --source 21 UnnamedClassWithAllowedMembers.java`
  */
 
@@ -20,7 +22,6 @@ static void instanceMethod() {
 	System.out.println("can have any instance method");
 }
 
-
 void main() {
 	System.out.println("must always have a valid main method to launch");
 

Diff for: java-21/UnnamedClassWithInitializers.java

@@ -1,4 +1,7 @@
 /**
+ * Using JDK manually built from main branch.
+ * This code is not working with the JDK main branch.
+ *
  * To run: `java --enable-preview --source 21 UnnamedClassWithInitializers.java`
  */