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 }