1 /*
  2  * Copyright (c) 2002, 2025, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.  Oracle designates this
  8  * particular file as subject to the "Classpath" exception as provided
  9  * by Oracle in the LICENSE file that accompanied this code.
 10  *
 11  * This code is distributed in the hope that it will be useful, but WITHOUT
 12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 14  * version 2 for more details (a copy is included in the LICENSE file that
 15  * accompanied this code).
 16  *
 17  * You should have received a copy of the GNU General Public License version
 18  * 2 along with this work; if not, write to the Free Software Foundation,
 19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 20  *
 21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 22  * or visit www.oracle.com if you need additional information or have any
 23  * questions.
 24  */
 25 
 26 package sun.nio.ch;
 27 
 28 import java.util.concurrent.locks.LockSupport;
 29 import jdk.internal.access.JavaLangAccess;
 30 import jdk.internal.access.SharedSecrets;
 31 
 32 // Signalling operations on native threads
 33 //
 34 // On some operating systems (e.g., Linux), closing a channel while another
 35 // thread is blocked in an I/O operation upon that channel does not cause that
 36 // thread to be released.  This class provides access to the native threads
 37 // upon which Java threads are built, and defines a simple signal mechanism
 38 // that can be used to release a native thread from a blocking I/O operation.
 39 // On systems that do not require this type of signalling, the current() method
 40 // always returns -1 and the signal(long) method has no effect.
 41 
 42 public class NativeThread {
 43     private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess();
 44 
 45     private NativeThread() { }
 46 
 47     /**
 48      * Returns the Thread to signal the current thread.
 49      *
 50      * The first use of this method on a platform thread will capture the thread's
 51      * native thread ID.
 52      */
 53     public static Thread threadToSignal() {
 54         Thread t = Thread.currentThread();
 55         if (!t.isVirtual() && JLA.nativeThreadID(t) == 0) {
 56             JLA.setThreadNativeID(current0());
 57         }
 58         return t;
 59     }
 60 
 61     /**
 62      * Signals the given thread. For a platform thread it sends a signal to the thread.
 63      * For a virtual thread it just unparks it.
 64      * @throws IllegalStateException if the thread is a platform thread that hasn't set its native ID
 65      */
 66     public static void signal(Thread thread) {
 67         if (thread.isVirtual()) {
 68             LockSupport.unpark(thread);
 69         } else {
 70             long id = JLA.nativeThreadID(thread);
 71             if (id == 0)
 72                 throw new IllegalStateException("Native thread ID not set");
 73             signal0(id);
 74         }
 75     }
 76 
 77     /**
 78      * Return true if the operating system supports pending signals. If a signal is sent
 79      * to a thread but cannot be delivered immediately then it will be delivered when the
 80      * thread is in the appropriate state.
 81      */
 82     static boolean supportPendingSignals() {
 83         return supportPendingSignals0();
 84     }
 85 
 86     private static native boolean supportPendingSignals0();
 87 
 88     // Returns an opaque token representing the native thread underlying the
 89     // invoking Java thread.  On systems that do not require signalling, this
 90     // method always returns 0.
 91     //
 92     private static native long current0();
 93 
 94     // Signals the given native thread so as to release it from a blocking I/O
 95     // operation.  On systems that do not require signalling, this method has
 96     // no effect.
 97     //
 98     private static native void signal0(long tid);
 99 
100     private static native void init();
101 
102     static {
103         IOUtil.load();
104         init();
105     }
106 
107 }