Merge branch 'fibers' of https://github.com/openjdk/loom into fibers

Author: Leonid Mesnik

src/hotspot/share/prims/jni.cpp

@@ -101,7 +101,7 @@
 #include "jvmci/jvmciCompiler.hpp"
 #endif
 
-static jint CurrentVersion = JNI_VERSION_20;
+static jint CurrentVersion = JNI_VERSION_21;
 
 #if defined(_WIN32) && !defined(USE_VECTORED_EXCEPTION_HANDLING)
 extern LONG WINAPI topLevelExceptionFilter(_EXCEPTION_POINTERS* );

src/hotspot/share/prims/jvmti.xml

@@ -1724,13 +1724,9 @@ jvmtiEnv *jvmti;
       </errors>
     </function>
 
-    <function id="SuspendAllVirtualThreads" num="118" since="19">
+    <function id="SuspendAllVirtualThreads" num="118" since="21">
       <synopsis>Suspend All Virtual Threads</synopsis>
       <description>
-        <b> SuspendAllVirtualThreads is a preview API of the Java platform. </b>
-        <i>Preview features may be removed in a future release, or upgraded to
-        permanent features of the Java platform.</i>
-        <p/>
         Suspend all virtual threads except those in the exception list.
         Virtual threads that are currently suspended do not change state.
         Virtual threads may be resumed with
@@ -1850,13 +1846,9 @@ jvmtiEnv *jvmti;
       </errors>
     </function>
 
-   <function id="ResumeAllVirtualThreads" num="119" since="19">
+   <function id="ResumeAllVirtualThreads" num="119" since="21">
       <synopsis>Resume All Virtual Threads</synopsis>
       <description>
-        <b> ResumeAllVirtualThreads is a preview API of the Java platform. </b>
-        <i>Preview features may be removed in a future release, or upgraded to
-        permanent features of the Java platform.</i>
-        <p/>
         Resume all virtual threads except those in the exception list.
         Virtual threads that are currently resumed do not change state.
         Virtual threads may be suspended with
@@ -10650,12 +10642,8 @@ myInit() {
           called and <eventlink id="SampledObjectAlloc"></eventlink> events can be generated.
         </description>
       </capabilityfield>
-      <capabilityfield id="can_support_virtual_threads" since="19">
+      <capabilityfield id="can_support_virtual_threads" since="21">
         <description>
-          <b> can_support_virtual_threads is a preview API of the Java platform. </b>
-          <i>Preview features may be removed in a future release, or upgraded to
-          permanent features of the Java platform.</i>
-          <p/>
           Can support virtual threads.
           If this capability is enabled then the following functions can be called:
           <functionlink id="SuspendAllVirtualThreads"></functionlink>,
@@ -13036,12 +13024,8 @@ myInit() {
   </event>
 
  <event label="Virtual Thread Start"
-         id="VirtualThreadStart" const="JVMTI_EVENT_VIRTUAL_THREAD_START" filtered="thread" num="87" phase="start" since="19">
+         id="VirtualThreadStart" const="JVMTI_EVENT_VIRTUAL_THREAD_START" filtered="thread" num="87" phase="start" since="21">
     <description>
-      <b> VirtualThreadStart is a preview API of the Java platform. </b>
-      <i>Preview features may be removed in a future release, or upgraded to
-      permanent features of the Java platform.</i>
-      <p/>
       A virtual thread start event is generated before its initial method executes.
       <p/>
       The event is sent on the newly started <paramlink id="virtual_thread"></paramlink>.
@@ -13069,12 +13053,8 @@ myInit() {
   </event>
 
   <event label="Virtual Thread End"
-         id="VirtualThreadEnd" const="JVMTI_EVENT_VIRTUAL_THREAD_END" filtered="thread" num="88" phase="start" since="19">
+         id="VirtualThreadEnd" const="JVMTI_EVENT_VIRTUAL_THREAD_END" filtered="thread" num="88" phase="start" since="21">
     <description>
-      <b> VirtualThreadEnd is a preview API of the Java platform. </b>
-      <i>Preview features may be removed in a future release, or upgraded to
-      permanent features of the Java platform.</i>
-      <p/>
       A virtual thread end event is generated after its initial method has finished execution.
       <p/>
       The event is sent on the terminating <paramlink id="virtual_thread"></paramlink>.

src/hotspot/share/prims/jvmtiH.xsl

@@ -116,6 +116,7 @@ enum {
     JVMTI_VERSION_9   = 0x30090000,
     JVMTI_VERSION_11  = 0x300B0000,
     JVMTI_VERSION_19  = 0x30130000,
+    JVMTI_VERSION_21  = 0x30150000,
 
     JVMTI_VERSION = 0x30000000 + (</xsl:text>
   <xsl:value-of select="$majorversion"/>

src/hotspot/share/runtime/threads.cpp

@@ -1166,6 +1166,7 @@ jboolean Threads::is_supported_jni_version(jint version) {
   if (version == JNI_VERSION_10) return JNI_TRUE;
   if (version == JNI_VERSION_19) return JNI_TRUE;
   if (version == JNI_VERSION_20) return JNI_TRUE;
+  if (version == JNI_VERSION_21) return JNI_TRUE;
   return JNI_FALSE;
 }
 

src/java.base/share/classes/java/lang/System.java

@@ -89,7 +89,6 @@
 import jdk.internal.vm.annotation.ForceInline;
 import jdk.internal.vm.annotation.IntrinsicCandidate;
 import jdk.internal.vm.annotation.Stable;
-import jdk.internal.vm.annotation.ChangesCurrentThread;
 import sun.nio.fs.DefaultFileSystemProvider;
 import sun.reflect.annotation.AnnotationType;
 import sun.nio.ch.Interruptible;
@@ -2563,17 +2562,9 @@ public Thread currentCarrierThread() {
                 return Thread.currentCarrierThread();
             }
 
-            @ChangesCurrentThread
             public <V> V executeOnCarrierThread(Callable<V> task) throws Exception {
-                Thread thread = Thread.currentThread();
-                if (thread.isVirtual()) {
-                    Thread carrier = Thread.currentCarrierThread();
-                    carrier.setCurrentThread(carrier);
-                    try {
-                        return task.call();
-                    } finally {
-                        carrier.setCurrentThread(thread);
-                    }
+                if (Thread.currentThread() instanceof VirtualThread vthread) {
+                    return vthread.executeOnCarrierThread(task);
                 } else {
                     return task.call();
                 }

src/java.base/share/classes/java/lang/Thread.java

@@ -41,8 +41,6 @@
 import java.util.function.Predicate;
 import java.util.stream.Stream;
 import jdk.internal.event.ThreadSleepEvent;
-import jdk.internal.javac.PreviewFeature;
-import jdk.internal.misc.PreviewFeatures;
 import jdk.internal.misc.StructureViolationExceptions;
 import jdk.internal.misc.TerminatingThreadLocal;
 import jdk.internal.misc.Unsafe;
@@ -464,24 +462,32 @@ public static void sleep(long millis) throws InterruptedException {
         if (millis < 0) {
             throw new IllegalArgumentException("timeout value is negative");
         }
+        long nanos = MILLISECONDS.toNanos(millis);
 
-        if (currentThread() instanceof VirtualThread vthread) {
-            long nanos = MILLISECONDS.toNanos(millis);
-            vthread.sleepNanos(nanos);
-            return;
-        }
-
+        // create jdk.ThreadSleepEvent event if enabled
+        ThreadSleepEvent event = null;
         if (ThreadSleepEvent.isTurnedOn()) {
-            ThreadSleepEvent event = new ThreadSleepEvent();
             try {
-                event.time = MILLISECONDS.toNanos(millis);
+                event = new ThreadSleepEvent();
+                event.time = nanos;
                 event.begin();
+            } catch (OutOfMemoryError e) {
+                event = null;
+            }
+        }
+
+        try {
+            if (currentThread() instanceof VirtualThread vthread) {
+                vthread.sleepNanos(nanos);
+            } else {
                 sleep0(millis);
-            } finally {
-                event.commit();
             }
-        } else {
-            sleep0(millis);
+        } finally {
+            try {
+                if (event != null) event.commit();
+            } catch (OutOfMemoryError e) {
+                // ignore
+            }
         }
     }
 
@@ -518,14 +524,6 @@ public static void sleep(long millis, int nanos) throws InterruptedException {
             throw new IllegalArgumentException("nanosecond timeout value out of range");
         }
 
-        if (currentThread() instanceof VirtualThread vthread) {
-            // total sleep time, in nanoseconds
-            long totalNanos = MILLISECONDS.toNanos(millis);
-            totalNanos += Math.min(Long.MAX_VALUE - totalNanos, nanos);
-            vthread.sleepNanos(totalNanos);
-            return;
-        }
-
         if (nanos > 0 && millis < Long.MAX_VALUE) {
             millis++;
         }
@@ -550,20 +548,40 @@ public static void sleep(long millis, int nanos) throws InterruptedException {
      */
     public static void sleep(Duration duration) throws InterruptedException {
         long nanos = NANOSECONDS.convert(duration);  // MAX_VALUE if > 292 years
-        if (nanos < 0)
+        if (nanos < 0) {
             return;
+        }
 
-        if (currentThread() instanceof VirtualThread vthread) {
-            vthread.sleepNanos(nanos);
-            return;
+        // create jdk.ThreadSleepEvent event if enabled
+        ThreadSleepEvent event = null;
+        if (ThreadSleepEvent.isTurnedOn()) {
+            try {
+                event = new ThreadSleepEvent();
+                event.time = nanos;
+                event.begin();
+            } catch (OutOfMemoryError e) {
+                event = null;
+            }
         }
 
-        // convert to milliseconds
-        long millis = MILLISECONDS.convert(nanos, NANOSECONDS);
-        if (nanos > NANOSECONDS.convert(millis, MILLISECONDS)) {
-            millis += 1L;
+        try {
+            if (currentThread() instanceof VirtualThread vthread) {
+                vthread.sleepNanos(nanos);
+            } else {
+                // convert to milliseconds
+                long millis = NANOSECONDS.toMillis(nanos);
+                if (nanos > MILLISECONDS.toNanos(millis)) {
+                    millis += 1L;
+                }
+                sleep0(millis);
+            }
+        } finally {
+            try {
+                if (event != null) event.commit();
+            } catch (OutOfMemoryError e) {
+                // ignore
+            }
         }
-        sleep(millis);
     }
 
     /**
@@ -611,7 +629,7 @@ public static void onSpinWait() {}
      * the constructing thread.
      * See Thread initialization.
      */
-    static final int NO_INHERIT_THREAD_LOCALS = 1 << 1;
+    static final int NO_INHERIT_THREAD_LOCALS = 1 << 2;
 
     /**
      * Helper class to generate thread identifiers. The identifiers start at
@@ -800,9 +818,8 @@ private static ClassLoader contextClassLoader(Thread parent) {
      * }
      *
      * @return A builder for creating {@code Thread} or {@code ThreadFactory} objects.
-     * @since 19
+     * @since 21
      */
-    @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS)
     public static Builder.OfPlatform ofPlatform() {
         return new ThreadBuilders.PlatformThreadBuilder();
     }
@@ -821,12 +838,9 @@ public static Builder.OfPlatform ofPlatform() {
      * }
      *
      * @return A builder for creating {@code Thread} or {@code ThreadFactory} objects.
-     * @throws UnsupportedOperationException if preview features are not enabled
-     * @since 19
+     * @since 21
      */
-    @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS)
     public static Builder.OfVirtual ofVirtual() {
-        PreviewFeatures.ensureEnabled();
         return new ThreadBuilders.VirtualThreadBuilder();
     }
 
@@ -856,14 +870,10 @@ public static Builder.OfVirtual ofVirtual() {
      *
      * @see Thread#ofPlatform()
      * @see Thread#ofVirtual()
-     * @since 19
+     * @since 21
      */
-    @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS)
     public sealed interface Builder
-            permits Builder.OfPlatform,
-                    Builder.OfVirtual,
-                    ThreadBuilders.BaseThreadBuilder {
-
+            permits Builder.OfPlatform, Builder.OfVirtual {
 
         /**
          * Sets the thread name.
@@ -962,9 +972,8 @@ public sealed interface Builder
          * this interface causes a {@code NullPointerException} to be thrown.
          *
          * @see Thread#ofPlatform()
-         * @since 19
+         * @since 21
          */
-        @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS)
         sealed interface OfPlatform extends Builder
                 permits ThreadBuilders.PlatformThreadBuilder {
 
@@ -1037,9 +1046,8 @@ default OfPlatform daemon() {
          * this interface causes a {@code NullPointerException} to be thrown.
          *
          * @see Thread#ofVirtual()
-         * @since 19
+         * @since 21
          */
-        @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS)
         sealed interface OfVirtual extends Builder
                 permits ThreadBuilders.VirtualThreadBuilder {
 
@@ -1467,14 +1475,11 @@ public Thread(ThreadGroup group, Runnable task, String name,
      *
      * @param task the object to run when the thread executes
      * @return a new, and started, virtual thread
-     * @throws UnsupportedOperationException if preview features are not enabled
      * @see <a href="#inheritance">Inheritance when creating threads</a>
-     * @since 19
+     * @since 21
      */
-    @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS)
     public static Thread startVirtualThread(Runnable task) {
         Objects.requireNonNull(task);
-        PreviewFeatures.ensureEnabled();
         var thread = ThreadBuilders.newVirtualThread(null, null, 0, task);
         thread.start();
         return thread;
@@ -1486,9 +1491,8 @@ public static Thread startVirtualThread(Runnable task) {
      *
      * @return {@code true} if this thread is a virtual thread
      *
-     * @since 19
+     * @since 21
      */
-    @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS)
     public final boolean isVirtual() {
         return (this instanceof BaseVirtualThread);
     }
@@ -1523,6 +1527,8 @@ void start(ThreadContainer container) {
                 throw new IllegalThreadStateException();
 
             // bind thread to container
+            if (this.container != null)
+                throw new IllegalThreadStateException();
             setThreadContainer(container);
 
             // start thread
@@ -1597,15 +1603,17 @@ void clearReferences() {
      * a chance to clean up before it actually exits.
      */
     private void exit() {
-        // pop any remaining scopes from the stack, this may block
-        if (headStackableScopes != null) {
-            StackableScope.popAll();
-        }
-
-        // notify container that thread is exiting
-        ThreadContainer container = threadContainer();
-        if (container != null) {
-            container.onExit(this);
+        try {
+            // pop any remaining scopes from the stack, this may block
+            if (headStackableScopes != null) {
+                StackableScope.popAll();
+            }
+        } finally {
+            // notify container that thread is exiting
+            ThreadContainer container = threadContainer();
+            if (container != null) {
+                container.onExit(this);
+            }
         }
 
         try {

src/java.base/share/classes/java/lang/ThreadBuilders.java

@@ -24,7 +24,6 @@
  */
 package java.lang;
 
-import java.lang.Thread.Builder;
 import java.lang.Thread.Builder.OfPlatform;
 import java.lang.Thread.Builder.OfVirtual;
 import java.lang.Thread.UncaughtExceptionHandler;
@@ -41,12 +40,12 @@
  * Defines static methods to create platform and virtual thread builders.
  */
 class ThreadBuilders {
+    private ThreadBuilders() { }
 
     /**
-     * Base implementation of ThreadBuilder.
+     * Base class for Thread.Builder implementations.
      */
-    static abstract non-sealed
-    class BaseThreadBuilder<T extends Builder> implements Builder {
+    private static class BaseThreadBuilder {
         private String name;
         private long counter;
         private int characteristics;
@@ -76,49 +75,37 @@ String nextThreadName() {
             }
         }
 
-        @Override
-        @SuppressWarnings("unchecked")
-        public T name(String name) {
+        void setName(String name) {
             this.name = Objects.requireNonNull(name);
             this.counter = -1;
-            return (T) this;
         }
 
-        @Override
-        @SuppressWarnings("unchecked")
-        public T name(String prefix, long start) {
+        void setName(String prefix, long start) {
             Objects.requireNonNull(prefix);
             if (start < 0)
                 throw new IllegalArgumentException("'start' is negative");
             this.name = prefix;
             this.counter = start;
-            return (T) this;
         }
 
-        @Override
-        @SuppressWarnings("unchecked")
-        public T inheritInheritableThreadLocals(boolean inherit) {
+        void setInheritInheritableThreadLocals(boolean inherit) {
             if (inherit) {
                 characteristics &= ~Thread.NO_INHERIT_THREAD_LOCALS;
             } else {
                 characteristics |= Thread.NO_INHERIT_THREAD_LOCALS;
             }
-            return (T) this;
         }
 
-        @Override
-        @SuppressWarnings("unchecked")
-        public T uncaughtExceptionHandler(UncaughtExceptionHandler ueh) {
+        void setUncaughtExceptionHandler(UncaughtExceptionHandler ueh) {
             this.uhe = Objects.requireNonNull(ueh);
-            return (T) this;
         }
     }
 
     /**
      * ThreadBuilder.OfPlatform implementation.
      */
     static final class PlatformThreadBuilder
-            extends BaseThreadBuilder<OfPlatform> implements OfPlatform {
+            extends BaseThreadBuilder implements OfPlatform {
         private ThreadGroup group;
         private boolean daemon;
         private boolean daemonChanged;
@@ -134,6 +121,30 @@ String nextThreadName() {
             return (name != null) ? name : Thread.genThreadName();
         }
 
+        @Override
+        public OfPlatform name(String name) {
+            setName(name);
+            return this;
+        }
+
+        @Override
+        public OfPlatform name(String prefix, long start) {
+            setName(prefix, start);
+            return this;
+        }
+
+        @Override
+        public OfPlatform inheritInheritableThreadLocals(boolean inherit) {
+            setInheritInheritableThreadLocals(inherit);
+            return this;
+        }
+
+        @Override
+        public OfPlatform uncaughtExceptionHandler(UncaughtExceptionHandler ueh) {
+            setUncaughtExceptionHandler(ueh);
+            return this;
+        }
+
         @Override
         public OfPlatform group(ThreadGroup group) {
             this.group = Objects.requireNonNull(group);
@@ -197,7 +208,7 @@ public ThreadFactory factory() {
      * ThreadBuilder.OfVirtual implementation.
      */
     static final class VirtualThreadBuilder
-            extends BaseThreadBuilder<OfVirtual> implements OfVirtual {
+            extends BaseThreadBuilder implements OfVirtual {
         private Executor scheduler;
 
         VirtualThreadBuilder() {
@@ -210,6 +221,30 @@ static final class VirtualThreadBuilder
             this.scheduler = Objects.requireNonNull(scheduler);
         }
 
+        @Override
+        public OfVirtual name(String name) {
+            setName(name);
+            return this;
+        }
+
+        @Override
+        public OfVirtual name(String prefix, long start) {
+            setName(prefix, start);
+            return this;
+        }
+
+        @Override
+        public OfVirtual inheritInheritableThreadLocals(boolean inherit) {
+            setInheritInheritableThreadLocals(inherit);
+            return this;
+        }
+
+        @Override
+        public OfVirtual uncaughtExceptionHandler(UncaughtExceptionHandler ueh) {
+            setUncaughtExceptionHandler(ueh);
+            return this;
+        }
+
         @Override
         public Thread unstarted(Runnable task) {
             Objects.requireNonNull(task);

src/java.base/share/classes/java/lang/ThreadLocal.java

@@ -29,9 +29,11 @@
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
 
 import jdk.internal.misc.CarrierThreadLocal;
 import jdk.internal.misc.TerminatingThreadLocal;
+import sun.security.action.GetPropertyAction;
 
 /**
  * This class provides thread-local variables.  These variables differ from
@@ -77,6 +79,8 @@
  * @since   1.2
  */
 public class ThreadLocal<T> {
+    private static final boolean TRACE_VTHREAD_LOCALS = traceVirtualThreadLocals();
+
     /**
      * ThreadLocals rely on per-thread linear-probe hash maps attached
      * to each thread (Thread.threadLocals and
@@ -228,6 +232,9 @@ private T setInitialValue(Thread t) {
         if (this instanceof TerminatingThreadLocal<?> ttl) {
             TerminatingThreadLocal.register(ttl);
         }
+        if (TRACE_VTHREAD_LOCALS) {
+            dumpStackIfVirtualThread();
+        }
         return value;
     }
 
@@ -242,6 +249,9 @@ private T setInitialValue(Thread t) {
      */
     public void set(T value) {
         set(Thread.currentThread(), value);
+        if (TRACE_VTHREAD_LOCALS) {
+            dumpStackIfVirtualThread();
+        }
     }
 
     void setCarrierThreadLocal(T value) {
@@ -788,4 +798,43 @@ private void expungeStaleEntries() {
             }
         }
     }
+
+
+    /**
+     * Reads the value of the jdk.traceVirtualThreadLocals property to determine if
+     * a stack trace should be printed when a virtual threads sets a thread local.
+     */
+    private static boolean traceVirtualThreadLocals() {
+        String propValue = GetPropertyAction.privilegedGetProperty("jdk.traceVirtualThreadLocals");
+        return (propValue != null)
+                && (propValue.isEmpty() || Boolean.parseBoolean(propValue));
+    }
+
+    /**
+     * Print a stack trace if the current thread is a virtual thread.
+     */
+    static void dumpStackIfVirtualThread() {
+        if (Thread.currentThread() instanceof VirtualThread vthread) {
+            try {
+                var stack = StackWalkerHolder.STACK_WALKER.walk(s ->
+                        s.skip(1)  // skip caller
+                         .collect(Collectors.toList()));
+
+                // switch to carrier thread to avoid recursive use of thread-locals
+                vthread.executeOnCarrierThread(() -> {
+                    System.out.println(vthread);
+                    for (StackWalker.StackFrame frame : stack) {
+                        System.out.format("    %s%n", frame.toStackTraceElement());
+                    }
+                    return null;
+                });
+            } catch (Exception e) {
+                throw new InternalError(e);
+            }
+        }
+    }
+
+    private static class StackWalkerHolder {
+        static final StackWalker STACK_WALKER = StackWalker.getInstance();
+    }
 }

src/java.base/share/classes/java/lang/VirtualThread.java

@@ -29,6 +29,7 @@
 import java.security.PrivilegedAction;
 import java.util.Locale;
 import java.util.Objects;
+import java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
@@ -40,7 +41,6 @@
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
-import jdk.internal.event.ThreadSleepEvent;
 import jdk.internal.event.VirtualThreadEndEvent;
 import jdk.internal.event.VirtualThreadPinnedEvent;
 import jdk.internal.event.VirtualThreadStartEvent;
@@ -216,7 +216,7 @@ private void runContinuation() {
             cont.run();
         } finally {
             if (cont.isDone()) {
-                afterTerminate(/*executed*/ true);
+                afterTerminate();
             } else {
                 afterYield();
             }
@@ -411,6 +411,20 @@ private void switchToVirtualThread(VirtualThread vthread, boolean notifyJvmti) {
         }
     }
 
+    /**
+     * Executes the given value returning task on the current carrier thread.
+     */
+    @ChangesCurrentThread
+    <V> V executeOnCarrierThread(Callable<V> task) throws Exception {
+        assert Thread.currentThread() == this;
+        boolean notifyJvmti = switchToCarrierThread();
+        try {
+            return task.call();
+        } finally {
+            switchToVirtualThread(this, notifyJvmti);
+        }
+     }
+
     /**
      * Unmounts this virtual thread, invokes Continuation.yield, and re-mounts the
      * thread when continued. When enabled, JVMTI must be notified from this method.
@@ -470,13 +484,22 @@ private void afterYield() {
         }
     }
 
+    /**
+     * Invoked after the thread terminates execution. It notifies anyone
+     * waiting for the thread to terminate.
+     */
+    private void afterTerminate() {
+        afterTerminate(true, true);
+    }
+
     /**
      * Invoked after the thread terminates (or start failed). This method
      * notifies anyone waiting for the thread to terminate.
      *
+     * @param notifyContainer true if its container should be notified
      * @param executed true if the thread executed, false if it failed to start
      */
-    private void afterTerminate(boolean executed) {
+    private void afterTerminate(boolean notifyContainer, boolean executed) {
         assert (state() == TERMINATED) && (carrierThread == null);
 
         if (executed) {
@@ -490,13 +513,13 @@ private void afterTerminate(boolean executed) {
             termination.countDown();
         }
 
-        if (executed) {
-            // notify container if thread executed
+        // notify container
+        if (notifyContainer) {
             threadContainer().onExit(this);
-
-            // clear references to thread locals
-            clearReferences();
         }
+
+        // clear references to thread locals
+        clearReferences();
     }
 
     /**
@@ -516,9 +539,12 @@ void start(ThreadContainer container) {
         setThreadContainer(container);
 
         // start thread
+        boolean addedToContainer = false;
         boolean started = false;
-        container.onStart(this); // may throw
         try {
+            container.onStart(this);  // may throw
+            addedToContainer = true;
+
             // scoped values may be inherited
             inheritScopedValueBindings(container);
 
@@ -528,8 +554,7 @@ void start(ThreadContainer container) {
         } finally {
             if (!started) {
                 setState(TERMINATED);
-                container.onExit(this);
-                afterTerminate(/*executed*/ false);
+                afterTerminate(addedToContainer, /*executed*/false);
             }
         }
     }
@@ -558,14 +583,21 @@ void park() {
             return;
 
         // park the thread
+        boolean yielded = false;
         setState(PARKING);
         try {
-            if (!yieldContinuation()) {
-                // park on the carrier thread when pinned
-                parkOnCarrierThread(false, 0);
-            }
+            yielded = yieldContinuation();  // may throw
         } finally {
-            assert (Thread.currentThread() == this) && (state() == RUNNING);
+            assert (Thread.currentThread() == this)
+                && ((yielded && state() == RUNNING) ^ (!yielded && state() == PARKING));
+            if (state() != RUNNING) {
+                setState(RUNNING);
+            }
+        }
+
+        // park on the carrier thread when pinned
+        if (!yielded) {
+            parkOnCarrierThread(false, 0);
         }
     }
 
@@ -589,14 +621,17 @@ void parkNanos(long nanos) {
         if (nanos > 0) {
             long startTime = System.nanoTime();
 
-            boolean yielded;
+            boolean yielded = false;
             Future<?> unparker = scheduleUnpark(this::unpark, nanos);
             setState(PARKING);
             try {
-                yielded = yieldContinuation();
+                yielded = yieldContinuation();  // may throw
             } finally {
                 assert (Thread.currentThread() == this)
-                        && (state() == RUNNING || state() == PARKING);
+                    && ((yielded && state() == RUNNING) ^ (!yielded && state() == PARKING));
+                if (state() != RUNNING) {
+                    setState(RUNNING);
+                }
                 cancel(unparker);
             }
 
@@ -618,10 +653,15 @@ void parkNanos(long nanos) {
      * @param nanos the waiting time in nanoseconds
      */
     private void parkOnCarrierThread(boolean timed, long nanos) {
-        assert state() == PARKING;
+        assert state() == RUNNING;
 
-        var pinnedEvent = new VirtualThreadPinnedEvent();
-        pinnedEvent.begin();
+        VirtualThreadPinnedEvent event;
+        try {
+            event = new VirtualThreadPinnedEvent();
+            event.begin();
+        } catch (OutOfMemoryError e) {
+            event = null;
+        }
 
         setState(PINNED);
         try {
@@ -639,7 +679,13 @@ private void parkOnCarrierThread(boolean timed, long nanos) {
         // consume parking permit
         setParkPermit(false);
 
-        pinnedEvent.commit();
+        if (event != null) {
+            try {
+                event.commit();
+            } catch (OutOfMemoryError e) {
+                // ignore
+            }
+        }
     }
 
     /**
@@ -715,7 +761,7 @@ void tryYield() {
         assert Thread.currentThread() == this;
         setState(YIELDING);
         try {
-            yieldContinuation();
+            yieldContinuation();  // may throw
         } finally {
             assert Thread.currentThread() == this;
             if (state() != RUNNING) {
@@ -725,30 +771,6 @@ void tryYield() {
         }
     }
 
-    /**
-     * Sleep the current virtual thread for the given sleep time.
-     *
-     * @param nanos the maximum number of nanoseconds to sleep
-     * @throws InterruptedException if interrupted while sleeping
-     */
-    void sleepNanos(long nanos) throws InterruptedException {
-        assert Thread.currentThread() == this;
-        if (nanos >= 0) {
-            if (ThreadSleepEvent.isTurnedOn()) {
-                ThreadSleepEvent event = new ThreadSleepEvent();
-                try {
-                    event.time = nanos;
-                    event.begin();
-                    doSleepNanos(nanos);
-                } finally {
-                    event.commit();
-                }
-            } else {
-                doSleepNanos(nanos);
-            }
-        }
-    }
-
     /**
      * Sleep the current thread for the given sleep time (in nanoseconds). If
      * nanos is 0 then the thread will attempt to yield.
@@ -758,9 +780,12 @@ void sleepNanos(long nanos) throws InterruptedException {
      * will consume the parking permit so this method makes available the parking
      * permit after the sleep. This may be observed as a spurious, but benign,
      * wakeup when the thread subsequently attempts to park.
+     *
+     * @param nanos the maximum number of nanoseconds to sleep
+     * @throws InterruptedException if interrupted while sleeping
      */
-    private void doSleepNanos(long nanos) throws InterruptedException {
-        assert nanos >= 0;
+    void sleepNanos(long nanos) throws InterruptedException {
+        assert Thread.currentThread() == this && nanos >= 0;
         if (getAndClearInterrupt())
             throw new InterruptedException();
         if (nanos == 0) {

src/java.base/share/classes/java/util/concurrent/Executors.java

@@ -46,7 +46,6 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
-import jdk.internal.javac.PreviewFeature;
 import jdk.internal.ref.CleanerFactory;
 import sun.security.util.SecurityConstants;
 
@@ -249,9 +248,8 @@ public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
      * @param threadFactory the factory to use when creating new threads
      * @return a new executor that creates a new Thread for each task
      * @throws NullPointerException if threadFactory is null
-     * @since 19
+     * @since 21
      */
-    @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS)
     public static ExecutorService newThreadPerTaskExecutor(ThreadFactory threadFactory) {
         return ThreadPerTaskExecutor.create(threadFactory);
     }
@@ -265,10 +263,8 @@ public static ExecutorService newThreadPerTaskExecutor(ThreadFactory threadFacto
      * that creates virtual threads.
      *
      * @return a new executor that creates a new virtual Thread for each task
-     * @throws UnsupportedOperationException if preview features are not enabled
-     * @since 19
+     * @since 21
      */
-    @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS)
     public static ExecutorService newVirtualThreadPerTaskExecutor() {
         ThreadFactory factory = Thread.ofVirtual().factory();
         return newThreadPerTaskExecutor(factory);

src/java.base/share/classes/jdk/internal/misc/PreviewFeatures.java

@@ -37,7 +37,7 @@ private PreviewFeatures() {
      * {@return true if preview features are enabled, otherwise false}
      */
     public static boolean isEnabled() {
-        return true; // FIXME: return true until test environment ready
+        return ENABLED;
     }
 
     /**

src/java.base/share/classes/jdk/internal/vm/Continuation.java

@@ -25,7 +25,6 @@
 
 package jdk.internal.vm;
 
-import jdk.internal.misc.PreviewFeatures;
 import jdk.internal.misc.Unsafe;
 import jdk.internal.vm.annotation.DontInline;
 import jdk.internal.vm.annotation.IntrinsicCandidate;
@@ -34,9 +33,7 @@
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.VarHandle;
 import java.util.EnumSet;
-import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Supplier;
 import jdk.internal.access.JavaLangAccess;
 import jdk.internal.access.SharedSecrets;
@@ -50,7 +47,6 @@ public class Continuation {
     private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess();
     static {
         ContinuationSupport.ensureSupported();
-        PreviewFeatures.ensureEnabled();
 
         StackChunk.init(); // ensure StackChunk class is initialized
 

src/java.base/share/native/include/jni.h

@@ -1992,6 +1992,7 @@ JNI_OnUnload(JavaVM *vm, void *reserved);
 #define JNI_VERSION_10  0x000a0000
 #define JNI_VERSION_19  0x00130000
 #define JNI_VERSION_20  0x00140000
+#define JNI_VERSION_21  0x00150000
 
 #ifdef __cplusplus
 } /* extern "C" */

src/java.se/share/data/jdwp/jdwp.spec

@@ -2156,10 +2156,6 @@ JDWP "Java(tm) Debug Wire Protocol"
         )
     )
     (Command IsVirtual=15
-        "<b>IsVirtual is a preview API of the Java platform.</b> "
-        "<em>Preview features may be removed in a future release, or upgraded to "
-        "permanent features of the Java platform.</em> Since JDWP version 19."
-        "<p>"
         "Determine if a thread is a "
         "<a href=../../api/java.base/java/lang/Thread.html#virtual-threads>virtual thread</a>."
         (Out
@@ -2537,10 +2533,6 @@ JDWP "Java(tm) Debug Wire Protocol"
                         )
                     )
                     (Alt PlatformThreadsOnly=13
-                        "<b>PlatformThreadsOnly is a preview API of the Java platform.</b> "
-                        "<em>Preview features may be removed in a future release, or upgraded to "
-                        "permanent features of the Java platform.</em> Since JDWP version 19."
-                        "<p>"
                         "For thread start and thread end events, restrict the "
                         "events so they are only sent for platform threads."
                     )

src/jdk.incubator.concurrent/share/classes/jdk/incubator/concurrent/StructuredTaskScope.java

@@ -46,7 +46,6 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Function;
-import jdk.internal.misc.PreviewFeatures;
 import jdk.internal.misc.ThreadFlock;
 
 /**
@@ -335,11 +334,8 @@ public StructuredTaskScope(String name, ThreadFactory factory) {
      *
      * <p> This constructor is equivalent to invoking the 2-arg constructor with a name
      * of {@code null} and a thread factory that creates virtual threads.
-     *
-     * @throws UnsupportedOperationException if preview features are not enabled
      */
     public StructuredTaskScope() {
-        PreviewFeatures.ensureEnabled();
         this.factory = Thread.ofVirtual().factory();
         this.flock = ThreadFlock.open(null);
     }

src/jdk.jdi/share/classes/com/sun/jdi/ThreadReference.java

@@ -27,7 +27,6 @@
 
 import java.util.List;
 import com.sun.jdi.event.EventSet;
-import jdk.internal.javac.PreviewFeature;
 
 /**
  * A thread object from the target VM.
@@ -516,9 +515,8 @@ void forceEarlyReturn(Value value) throws InvalidTypeException,
      * @implSpec
      * The default implementation throws {@code UnsupportedOperationException}.
      *
-     * @since 19
+     * @since 21
      */
-    @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS, reflective = true)
     default boolean isVirtual() {
         throw new UnsupportedOperationException("Method not implemented");
     }

src/jdk.jdi/share/classes/com/sun/jdi/request/ThreadDeathRequest.java

@@ -29,7 +29,6 @@
 import com.sun.jdi.event.EventQueue;
 import com.sun.jdi.event.EventSet;
 import com.sun.jdi.event.ThreadDeathEvent;
-import jdk.internal.javac.PreviewFeature;
 
 /**
  * Request for notification when a thread terminates in the target VM.
@@ -70,9 +69,8 @@ public interface ThreadDeathRequest extends EventRequest {
      * @throws InvalidRequestStateException if this request is currently
      * enabled or has been deleted
      *
-     * @since 19
+     * @since 21
      */
-    @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS, reflective = true)
     default void addPlatformThreadsOnlyFilter() {
         throw new UnsupportedOperationException("Method not implemented");
     }

src/jdk.jdi/share/classes/com/sun/jdi/request/ThreadStartRequest.java

@@ -29,7 +29,6 @@
 import com.sun.jdi.event.EventQueue;
 import com.sun.jdi.event.EventSet;
 import com.sun.jdi.event.ThreadStartEvent;
-import jdk.internal.javac.PreviewFeature;
 
 /**
  * Request for notification when a thread starts execution in the target VM.
@@ -70,9 +69,8 @@ public interface ThreadStartRequest extends EventRequest {
      * @throws InvalidRequestStateException if this request is currently
      * enabled or has been deleted
      *
-     * @since 19
+     * @since 21
      */
-    @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS, reflective = true)
     default void addPlatformThreadsOnlyFilter() {
         throw new UnsupportedOperationException("Method not implemented");
     }

src/jdk.jdi/share/classes/com/sun/tools/example/debug/tty/TTYResources.java

@@ -477,7 +477,6 @@ public Object[][] getContents() {
              "                      connect to target VM using named connector with listed argument values\n" +
              "    -dbgtrace [flags] print info for debugging {0}\n" +
              "    -trackallthreads  Track all threads, including virtual threads.\n" +
-             "                      Virtual threads are a preview feature of the Java platform.\n" +
              "    -tclient          run the application in the HotSpot(TM) Client Compiler\n" +
              "    -tserver          run the application in the HotSpot(TM) Server Compiler\n" +
              "    -R<option>        forward <option> to debuggee process if launched by jdb, otherwise ignored\n" +

src/jdk.jdi/share/classes/com/sun/tools/jdi/resources/jdi.properties

@@ -45,7 +45,7 @@ sun.quote = Character used to combine space-delimited text into a single command
 sun.quote.label = Quote
 sun.vm_exec = Name of the Java VM launcher
 sun.vm_exec.label = Launcher
-sun.include_virtualthreads = List of all threads includes virtual threads as well as platform threads. Virtual threads are a preview feature of the Java platform.
+sun.include_virtualthreads = List of all threads includes virtual threads as well as platform threads.
 sun.include_virtualthreads.label = Include Virtual Threads
 sun.description = Launches target using Sun Java VM command line and attaches to it
 generic_attaching.address = Address to which to attach for VM connections

src/jdk.jdwp.agent/share/native/libjdwp/debugInit.c

@@ -827,7 +827,6 @@ printUsage(void)
  "onuncaught=y|n                   debug on any uncaught?            n\n"
  "timeout=<timeout value>          for listen/attach in milliseconds n\n"
  "includevirtualthreads=y|n        List of all threads includes virtual threads as well as platform threads.\n"
- "                                 Virtual threads are a preview feature of the Java platform.\n"
  "                                                                   n\n"
  "mutf8=y|n                        output modified utf-8             n\n"
  "quiet=y|n                        control over terminal messages    n\n"));

src/jdk.jfr/share/classes/jdk/jfr/consumer/RecordedThread.java

@@ -26,7 +26,6 @@
 package jdk.jfr.consumer;
 
 import jdk.jfr.internal.consumer.ObjectContext;
-import jdk.internal.javac.PreviewFeature;
 
 /**
  * A recorded thread.
@@ -113,9 +112,8 @@ public long getId() {
     /**
      * {@return {@code true} if this is a virtual Thread, {@code false} otherwise}
      *
-     * @since 19
+     * @since 21
      */
-    @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS, reflective = true)
     public boolean isVirtual() {
         return getTyped("virtual", Boolean.class, Boolean.FALSE);
     }

src/jdk.management/share/classes/com/sun/management/HotSpotDiagnosticMXBean.java

@@ -27,7 +27,6 @@
 
 import java.io.IOException;
 import java.lang.management.PlatformManagedObject;
-import jdk.internal.javac.PreviewFeature;
 
 /**
  * Diagnostic management interface for the HotSpot Virtual Machine.
@@ -147,31 +146,23 @@ public interface HotSpotDiagnosticMXBean extends PlatformManagedObject {
      *         access to the file or {@link java.lang.management.ManagementPermission
      *         ManagementPermission("control")} is denied
      * @throws UnsupportedOperationException if this operation is not supported
-     * @since 19
+     * @since 21
      */
-    @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS, reflective = true)
     default void dumpThreads(String outputFile, ThreadDumpFormat format) throws IOException {
         throw new UnsupportedOperationException();
     }
 
     /**
      * Thread dump format.
-     * @since 19
+     * @since 21
      */
-    @PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL_THREADS, reflective = true)
     public static enum ThreadDumpFormat {
         /**
          * Plain text format.
          */
         TEXT_PLAIN,
         /**
-         * JSON (JavaScript Object Notation) format
-         * (<a href="https://tools.ietf.org/html/rfc8259">RFC 8259</a>).
-         *
-         * <p> <a href="doc-files/threadDump.schema.json">threadDump.schema.json</a>
-         * describes the thread dump format in draft
-         * <a href="https://tools.ietf.org/html/draft-json-schema-language-02">
-         * JSON Schema Language version 2</a>.
+         * JSON (JavaScript Object Notation) format.
          */
         JSON,
     }

test/hotspot/jtreg/native_sanity/JniVersion.java

@@ -27,12 +27,12 @@
  */
 public class JniVersion {
 
-    public static final int JNI_VERSION_20 = 0x00140000;
+    public static final int JNI_VERSION_21 = 0x00150000;
 
     public static void main(String... args) throws Exception {
         System.loadLibrary("JniVersion");
         int res = getJniVersion();
-        if (res != JNI_VERSION_20) {
+        if (res != JNI_VERSION_21) {
             throw new Exception("Unexpected value returned from getJniVersion(): 0x" + Integer.toHexString(res));
         }
     }

test/jdk/ProblemList.txt

@@ -784,10 +784,3 @@ java/awt/event/MouseEvent/SpuriousExitEnter/SpuriousExitEnter.java 8254841 macos
 java/awt/Focus/AppletInitialFocusTest/AppletInitialFocusTest1.java 8256289 windows-x64
 java/awt/FullScreen/TranslucentWindow/TranslucentWindow.java 8258103 linux-all
 java/awt/Focus/FrameMinimizeTest/FrameMinimizeTest.java 8016266 linux-x64
-
-############################################################################
-
-# Loom, fibers branch
-
-java/lang/Thread/virtual/PreviewFeaturesNotEnabled.java                     0000000 generic-all
-jdk/incubator/concurrent/StructuredTaskScope/PreviewFeaturesNotEnabled.java 0000000 generic-all

test/jdk/java/lang/Thread/virtual/PreviewFeaturesNotEnabled.java

@@ -1247,7 +1247,7 @@ void testSleep3(ThrowingRunnable sleeper) throws Exception {
         VThreadRunner.run(() -> {
             long start = millisTime();
             sleeper.run();
-            expectDuration(start, /*min*/900, /*max*/4000);
+            expectDuration(start, /*min*/900, /*max*/20_000);
         });
     }
 
@@ -1337,7 +1337,7 @@ void testSleep6() throws Exception {
 
             long start = millisTime();
             Thread.sleep(1000);
-            expectDuration(start, /*min*/900, /*max*/4000);
+            expectDuration(start, /*min*/900, /*max*/20_000);
 
             // check that parking permit was not consumed
             LockSupport.park();
@@ -1354,7 +1354,7 @@ void testSleep7() throws Exception {
             try {
                 long start = millisTime();
                 Thread.sleep(1000);
-                expectDuration(start, /*min*/900, /*max*/4000);
+                expectDuration(start, /*min*/900, /*max*/20_000);
             } catch (Exception e) {
                 exc.set(e);
             }
@@ -1382,7 +1382,7 @@ void testSleep8() throws Exception {
             synchronized (lock) {
                 Thread.sleep(1000);
             }
-            expectDuration(start, /*min*/900, /*max*/4000);
+            expectDuration(start, /*min*/900, /*max*/20_000);
         });
     }