src/java.base/unix/classes/sun/nio/ch/NativeThread.java

*** 23,10 ***
--- 23,13 ---
   * questions.
   */
  
  package sun.nio.ch;
  
+ import java.util.concurrent.locks.LockSupport;
+ import jdk.internal.access.JavaLangAccess;
+ import jdk.internal.access.SharedSecrets;
  
  // Signalling operations on native threads
  //
  // On some operating systems (e.g., Linux), closing a channel while another
  // thread is blocked in an I/O operation upon that channel does not cause that

*** 35,49 ***
  // that can be used to release a native thread from a blocking I/O operation.
  // On systems that do not require this type of signalling, the current() method
  // always returns -1 and the signal(long) method has no effect.
  
  public class NativeThread {
!     private static final long VIRTUAL_THREAD_ID = -1L;
  
!     /**
-      * Returns the id of the current native thread if the platform can signal
-      * native threads, 0 if the platform can not signal native threads, or
-      * -1L if the current thread is a virtual thread.
-      */
-     public static long current() {
-         if (Thread.currentThread().isVirtual()) {
-             return VIRTUAL_THREAD_ID;
-         } else {
-             return current0();
-         }
-     }
  
      /**
!      * Signals the given native thread.
       *
!      * @throws IllegalArgumentException if tid is not a token to a native thread
!      */
-     public static void signal(long tid) {
-         if (tid == 0 || tid == VIRTUAL_THREAD_ID)
-             throw new IllegalArgumentException();
-         signal0(tid);
-     }
- 
-     /**
-      * Returns true the tid is the id of a native thread.
       */
!     static boolean isNativeThread(long tid) {
!         return (tid != 0 && tid != VIRTUAL_THREAD_ID);
      }
  
      /**
!      * Returns true if tid is -1L.
!      * @see #current()
       */
!     static boolean isVirtualThread(long tid) {
!         return (tid == VIRTUAL_THREAD_ID);
      }
  
      /**
       * Return true if the operating system supports pending signals. If a signal is sent
       * to a thread but cannot be delivered immediately then it will be delivered when the
--- 38,42 ---
  // that can be used to release a native thread from a blocking I/O operation.
  // On systems that do not require this type of signalling, the current() method
  // always returns -1 and the signal(long) method has no effect.
  
  public class NativeThread {
!     private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess();
  
!     private NativeThread() { }
  
      /**
!      * Returns the Thread to signal the current thread.
       *
!      * The first use of this method on a platform thread will capture the thread's
!      * native thread ID.
       */
!     public static Thread threadToSignal() {
!         Thread t = Thread.currentThread();
+         if (!t.isVirtual() && JLA.nativeThreadID(t) == 0) {
+             JLA.setThreadNativeID(current0());
+         }
+         return t;
      }
  
      /**
!      * Signals the given thread. For a platform thread it sends a signal to the thread.
!      * For a virtual thread it just unparks it.
+      * @throws IllegalStateException if the thread is a platform thread that hasn't set its native ID
       */
!     public static void signal(Thread thread) {
!         if (thread.isVirtual()) {
+             LockSupport.unpark(thread);
+         } else {
+             long id = JLA.nativeThreadID(thread);
+             if (id == 0)
+                 throw new IllegalStateException("Native thread ID not set");
+             signal0(id);
+         }
      }
  
      /**
       * Return true if the operating system supports pending signals. If a signal is sent
       * to a thread but cannot be delivered immediately then it will be delivered when the