1 package sun.nio.ch;
2
3 public abstract interface Interruptible
4 {
5 public abstract void interrupt(Thread paramThread);
6 }
1 /**
中断此线程。
2 * Interrupts this thread.
3 * 除非当前线程正在中断自身（这始终是允许的），否则将调用此线程的{@link checkaccess（）checkaccess}方法，这可能会导致引发{@link securityexception}。
4 * <p> Unless the current thread is interrupting itself, which is
5 * always permitted, the {@link #checkAccess() checkAccess} method
6 * of this thread is invoked, which may cause a {@link
7 * SecurityException} to be thrown.
8 * 如果这个线程在调用{wait（）}、{wait（long）}、或{join（）}、{join（long）}、{join（long，int）}、{sleep（long）}、
或{sleep（long，int）}方法的{wait（long，int）}方法时被阻塞，那么它的中断状态将被清除，并接收{@link interruptedexception}。
9 * <p> If this thread is blocked in an invocation of the {@link
10 * Object#wait() wait()}, {@link Object#wait(long) wait(long)}, or {@link
11 * Object#wait(long, int) wait(long, int)} methods of the {@link Object}
12 * class, or of the {@link #join()}, {@link #join(long)}, {@link
13 * #join(long, int)}, {@link #sleep(long)}, or {@link #sleep(long, int)},
14 * methods of this class, then its interrupt status will be cleared and it
15 * will receive an {@link InterruptedException}.
16 * 如果此线程在{@link java.nio.channel s.interruptiblechannel interruptiblechannel}上的I/O操作中被阻塞，则通道将关闭，
线程的中断状态将被设置，线程将收到{@link java.nio.channels.closedbyInterruption}。
17 * <p> If this thread is blocked in an I/O operation upon an {@link
18 * java.nio.channels.InterruptibleChannel InterruptibleChannel}
19 * then the channel will be closed, the thread's interrupt
20 * status will be set, and the thread will receive a {@link
21 * java.nio.channels.ClosedByInterruptException}.
22 * 如果这个线程在{@link java.nio.channels.selector}中被阻塞，那么该线程的中断状态将被设置，并且它将立即从选择操作返回，可能具有非零值，
就像调用了选择器的{@link java.nio.channels.selector{wakeup-wakeup}方法一样。
23 * <p> If this thread is blocked in a {@link java.nio.channels.Selector}
24 * then the thread's interrupt status will be set and it will return
25 * immediately from the selection operation, possibly with a non-zero
26 * value, just as if the selector's {@link
27 * java.nio.channels.Selector#wakeup wakeup} method were invoked.
28 * 如果前面的条件都不成立，那么这个线程的中断状态将被设置。
29 * <p> If none of the previous conditions hold then this thread's interrupt
30 * status will be set. </p>
31 * 中断不活动的线程不必有任何效果。
32 * <p> Interrupting a thread that is not alive need not have any effect.
33 *
34 * @throws SecurityException
35 * if the current thread cannot modify this thread
36 *
37 * @revised 6.0
38 * @spec JSR-51
39 */
40 public void interrupt() {
41 if (this != Thread.currentThread())
42 checkAccess();
43
44 synchronized (blockerLock) {
45 Interruptible b = blocker;
46 if (b != null) {
47 interrupt0(); // Just to set the interrupt flag
48 b.interrupt(this);
49 return;
50 }
51 }
52 interrupt0();
53 }
1 void os::interrupt(Thread* thread) {
2
3 assert(Thread::current() == thread || Threads_lock->owned_by_self(),
4
5 "possibility of dangling Thread pointer");
6
7
8 OSThread* osthread = thread->osthread();
9
10
11 if (!osthread->interrupted()) {
12 设置中断标识
13 osthread->set_interrupted(true);
14
15 // More than one thread can get here with the same value of osthread,
16
17 // resulting in multiple notifications. We do, however, want the store
18
19 // to interrupted() to be visible to other threads before we execute unpark().
20
21 OrderAccess::fence();
22
23 ParkEvent * const slp = thread->_SleepEvent ;
24
25 if (slp != NULL) slp->unpark() ;
26
27 }
28
29
30 // For JSR166. Unpark even if interrupt status already was set
31
32 if (thread->is_Java_thread())
33
34 ((JavaThread*)thread)->parker()->unpark();
35
36
37 ParkEvent * ev = thread->_ParkEvent ;
38
39 if (ev != NULL) ev->unpark() ;
40
41
42 }
1 JVM_ENTRY(void, JVM_Interrupt(JNIEnv* env, jobject jthread))
2
3 JVMWrapper("JVM_Interrupt");
4
5
6 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate
7
8 oop java_thread = JNIHandles::resolve_non_null(jthread);
9
10 MutexLockerEx ml(thread->threadObj() == java_thread ? NULL : Threads_lock);
11
12 // We need to re-resolve the java_thread, since a GC might have happened during the
13
14 // acquire of the lock
15
16 JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread));
17
18 if (thr != NULL) {
19
20 Thread::interrupt(thr);
21
22 }
23
24 JVM_END