GROOVY-9381: add ScopedLocal

Author: daniellansun

src/main/java/groovy/concurrent/AsyncContext.java

@@ -20,6 +20,8 @@
 
 import groovy.lang.Closure;
 
+import org.apache.groovy.runtime.async.ScopedLocal;
+
 import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.Map;
@@ -50,21 +52,24 @@
  * {@code null} as a value removes the key.
  *
  * <h2>Thread safety</h2>
- * Each thread owns its own {@code AsyncContext} instance via a
- * {@link ThreadLocal}.  Instance methods ({@link #put}, {@link #get},
+ * Each thread owns its own {@code AsyncContext} instance via
+ * {@link ScopedLocal}.  On JDK&nbsp;25+, this leverages
+ * {@code ScopedValue} for optimal virtual-thread performance;
+ * on earlier JDKs it falls back to {@code ThreadLocal}.
+ * Instance methods ({@link #put}, {@link #get},
  * {@link #remove}) are <em>not</em> synchronized — they are only called
  * on the owning thread.  Static methods ({@link #withSnapshot},
- * {@link #capture}) follow a save-and-restore pattern protected by
- * {@code try/finally}, ensuring the previous context is always reinstated
- * even if the action throws.  This design prevents stale context from
- * leaking to thread-pool threads between task executions.
+ * {@link #capture}) use a scope-based binding pattern, ensuring the
+ * previous context is always reinstated even if the action throws.
+ * This design prevents stale context from leaking to thread-pool
+ * threads between task executions.
  *
  * @since 6.0.0
  */
 public final class AsyncContext {
 
-    private static final ThreadLocal<AsyncContext> CURRENT =
-            ThreadLocal.withInitial(AsyncContext::new);
+    private static final ScopedLocal<AsyncContext> CURRENT =
+            ScopedLocal.withInitial(AsyncContext::new);
 
     private final Map<String, Object> values;
 
@@ -120,13 +125,8 @@ public static Snapshot capture() {
     public static <T> T withSnapshot(Snapshot snapshot, Supplier<T> supplier) {
         Objects.requireNonNull(snapshot, "snapshot must not be null");
         Objects.requireNonNull(supplier, "supplier must not be null");
-        AsyncContext previous = CURRENT.get();
-        CURRENT.set(new AsyncContext(new LinkedHashMap<>(snapshot.values), true));
-        try {
-            return supplier.get();
-        } finally {
-            CURRENT.set(previous);
-        }
+        AsyncContext restored = new AsyncContext(new LinkedHashMap<>(snapshot.values), true);
+        return CURRENT.where(restored, supplier);
     }
 
     /**

src/main/java/groovy/concurrent/AsyncScope.java

@@ -21,6 +21,7 @@
 import groovy.lang.Closure;
 import org.apache.groovy.runtime.async.AsyncSupport;
 import org.apache.groovy.runtime.async.GroovyPromise;
+import org.apache.groovy.runtime.async.ScopedLocal;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -74,20 +75,21 @@
  * {@link #async(Closure)} and {@link #close()} cannot race: no child
  * can be registered after the scope is marked closed.</p>
  *
- * <h2>ThreadLocal management</h2>
- * <p>The {@link #withCurrent(AsyncScope, Supplier)} method uses a
- * save-and-restore pattern with a {@code try}/{@code finally} block,
- * guaranteeing that the previous scope binding is restored even if
- * the supplier throws.  Thread-pool threads therefore never retain
- * stale scope references across task boundaries.</p>
+ * <h2>Thread-scoped state management</h2>
+ * <p>The {@link #withCurrent(AsyncScope, Supplier)} method uses
+ * {@link ScopedLocal} to manage the current scope binding.  On
+ * JDK&nbsp;25+, this automatically leverages {@code ScopedValue} for
+ * optimal virtual-thread performance; on earlier JDKs it falls back to
+ * a {@code ThreadLocal} with a save-and-restore pattern inside
+ * {@code try}/{@code finally} blocks.</p>
  *
  * @see Awaitable
  * @see AsyncSupport
  * @since 6.0.0
  */
 public class AsyncScope implements AutoCloseable {
 
-    private static final ThreadLocal<AsyncScope> CURRENT = new ThreadLocal<>();
+    private static final ScopedLocal<AsyncScope> CURRENT = ScopedLocal.newInstance();
 
     /**
      * Pruning threshold: completed children are purged when the list
@@ -137,7 +139,7 @@ public AsyncScope() {
      * @return the current scope, or {@code null}
      */
     public static AsyncScope current() {
-        return CURRENT.get();
+        return CURRENT.orElse(null);
     }
 
     /**
@@ -151,21 +153,7 @@ public static AsyncScope current() {
      */
     public static <T> T withCurrent(AsyncScope scope, Supplier<T> supplier) {
         Objects.requireNonNull(supplier, "supplier must not be null");
-        AsyncScope previous = CURRENT.get();
-        if (scope == null) {
-            CURRENT.remove();
-        } else {
-            CURRENT.set(scope);
-        }
-        try {
-            return supplier.get();
-        } finally {
-            if (previous == null) {
-                CURRENT.remove();
-            } else {
-                CURRENT.set(previous);
-            }
-        }
+        return CURRENT.where(scope, supplier);
     }
 
     /**