< prev index next >

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

Print this page

  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 
 29 // Signalling operations on native threads
 30 //
 31 // On some operating systems (e.g., Linux), closing a channel while another
 32 // thread is blocked in an I/O operation upon that channel does not cause that
 33 // thread to be released.  This class provides access to the native threads
 34 // upon which Java threads are built, and defines a simple signal mechanism
 35 // that can be used to release a native thread from a blocking I/O operation.
 36 // On systems that do not require this type of signalling, the current() method
 37 // always returns -1 and the signal(long) method has no effect.
 38 
 39 public class NativeThread {
 40     private static final long VIRTUAL_THREAD_ID = -1L;
 41 
 42     /**
 43      * Returns the id of the current native thread if the platform can signal
 44      * native threads, 0 if the platform can not signal native threads, or
 45      * -1L if the current thread is a virtual thread.
 46      */
 47     public static long current() {
 48         if (Thread.currentThread().isVirtual()) {
 49             return VIRTUAL_THREAD_ID;
 50         } else {
 51             return current0();
 52         }
 53     }
 54 
 55     /**
 56      * Signals the given native thread.
 57      *
 58      * @throws IllegalArgumentException if tid is not a token to a native thread
 59      */
 60     public static void signal(long tid) {
 61         if (tid == 0 || tid == VIRTUAL_THREAD_ID)
 62             throw new IllegalArgumentException();
 63         signal0(tid);
 64     }
 65 
 66     /**
 67      * Returns true the tid is the id of a native thread.
 68      */
 69     static boolean isNativeThread(long tid) {
 70         return (tid != 0 && tid != VIRTUAL_THREAD_ID);




 71     }
 72 
 73     /**
 74      * Returns true if tid is -1L.
 75      * @see #current()

 76      */
 77     static boolean isVirtualThread(long tid) {
 78         return (tid == VIRTUAL_THREAD_ID);







 79     }
 80 
 81     /**
 82      * Return true if the operating system supports pending signals. If a signal is sent
 83      * to a thread but cannot be delivered immediately then it will be delivered when the
 84      * thread is in the appropriate state.
 85      */
 86     static boolean supportPendingSignals() {
 87         return supportPendingSignals0();
 88     }
 89 
 90     private static native boolean supportPendingSignals0();
 91 
 92     // Returns an opaque token representing the native thread underlying the
 93     // invoking Java thread.  On systems that do not require signalling, this
 94     // method always returns 0.
 95     //
 96     private static native long current0();
 97 
 98     // Signals the given native thread so as to release it from a blocking I/O

  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
< prev index next >