Thread的Interrupt()源代码分析(7)

谁践踏了优雅 2022-05-03 05:56 293阅读 0赞

接上一篇：[Thread的join()源代码分析(6)][Thread_join_6]

今天我们来学习下interrupt(),首先先看下api上对此方法的解释，关于interrupt的方法有三个

###      public void interrupt() ###

中断这个线程。

除非当前线程中断自身，这是始终允许的，所以调用此线程的`checkAccess`方法，这可能会导致抛出`SecurityException` 。

如果该线程阻塞的调用`wait()` ， `wait(long)` ，或`wait(long, int)`的方法`Object`类，或者在`join()` ， `join(long)` ， `join(long, int)` ， `sleep(long)` ，或`sleep(long, int)` ，这个类的方法，那么它的中断状态将被清除，并且将收到一个`InterruptedException` 。

如果该线程在可阻止在I / O操作`InterruptibleChannel`则信道将被关闭，该线程的中断状态将被设置，并且螺纹将收到一个`ClosedByInterruptException` 。

如果该线程在`Selector`中被阻塞，则线程的中断状态将被设置，并且它将从选择操作立即返回，可能具有非零值，就像调用了选择器的`wakeup`方法一样。

如果以前的条件都不成立，则该线程的中断状态将被设置。

中断不存在的线程不需要任何效果。

异常

`SecurityException` \- 如果当前线程不能修改此线程

### public static boolean interrupted() ###

测试当前线程是否中断。 该方法可以清除线程的*中断状态* 。 换句话说，如果这个方法被连续调用两次，那么第二个调用将返回false（除非当前线程再次中断，在第一个调用已经清除其中断状态之后，在第二个调用之前已经检查过）。

忽略线程中断，因为线程在中断时不存在将被该方法返回false所反映。

结果

`true`如果当前线程已被中断; `false`否则。

另请参见：

`isInterrupted()`

### public boolean isInterrupted() ###

测试这个线程是否被中断。 线程的*中断状态*不受此方法的影响。

忽略线程中断，因为线程在中断时不存在将被该方法返回false所反映。

结果

`true`如果这个线程已被中断; `false`否则。

另请参见：

`interrupted()`

`请看interrupt()的源代码：`

public void interrupt() {
            if (this != Thread.currentThread())
                checkAccess();
    /*判断是否为当前线程调用，如果不是则调用此线程的checkAccess方法，这可能会导致抛出SecurityException */
    
            synchronized (blockerLock) {
        /*blockerLock为当前线程创建时内部初始化的一个Object对象，被用作锁的标识对象,后面文章会讲到synchronized 同步锁*/
                Interruptible b = blocker;
                if (b != null) {
                    interrupt0();           // Just to set the interrupt flag
    /*只是赋给线程一个状态（中断）并不是会中断该线程*/
                    b.interrupt(this);
                    return;
                }
            }
            interrupt0();
        }

接下来我们看下实现代码：

public static void main(String[] args) {
    		//验证interrupt
    	Thread t = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				//打印当前线程是否是中断状态
    				while (true)
    				System.out.println(Thread.interrupted());
    			}
    		},"t1");
    		t.start();
    		t.interrupt();
    }

控制台打印：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_27_color_FFFFFF_t_70][]

而此时线程还是处于中断状态。说明此方法并不会中断线程，而是赋给了一个中断的状态。

而为什么会有两个判断线程中断状态的方法(isInterrupted()和iterrupted())呢？它们两个的区别在哪里呢？

请看说明：

interrupted():测试当前线程是否中断。 该方法可以清除线程的*中断状态* 。

isInterrupted():测试这个线程是否被中断。 线程的*中断状态*不受此方法的影响。

Thread t1 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				System.out.println(Thread.interrupted());
    				while(true){
    
    				}
    
    			}
    		});
    		t1.start();
    		t1.interrupt();
    		try {
    			Thread.sleep(1_000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("3"+t1.interrupted());
    		System.out.println("4"+t1.interrupted());

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_27_color_FFFFFF_t_70 1][]

再来看下isInterrupted()

Thread t1 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				System.out.println(Thread.currentThread().isInterrupted());
    				while(true){
    
    				}
    
    			}
    		});
    		t1.start();
    		t1.interrupt();
    		try {
    			Thread.sleep(1_000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println(t1.isInterrupted());
    		System.out.println(t1.isInterrupted());

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_27_color_FFFFFF_t_70 2][]

我们来看下源码给的解释：

public static boolean interrupted() {
            return currentThread().isInterrupted(true);
    //调用isInterrupted(flag)--有参重载
        }
    
      
        public boolean isInterrupted() {
            return isInterrupted(false);
    //调用isInterrupted(flag)--有参重载
        }
    
        /**
         *测试某些线程是否已被中断。中断状态根据传递的ClearInterrupted(即flag)值重置或不重置。
         */
        private native boolean isInterrupted(boolean ClearInterrupted);

上面我们从api中了解到，

那么我们来验证一下：

Thread t = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				//打印当前线程是否是中断状态
    				while (true){
    					try {
    						Thread.sleep(10000);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					System.out.println(Thread.interrupted());
    				}
    			}
    		},"t1");
    		t.start();
    		t.interrupt();

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_27_color_FFFFFF_t_70 3][]

注意，这里虽然会抛异常但是却没有结束线程，下篇我们将介绍几种结束线程的案例，接下来是wait。

//wait()时调用interrupt()
    		Thread t = new Thread(new Runnable() {
    			private final Object MONTI = new Object();
    			@Override
    			public void run() {
    				//打印当前线程是否是中断状态
    				while (true){
    					synchronized (MONTI){
    						try {
    							o.wait();
    						} catch (InterruptedException e) {
    							e.printStackTrace();
    						}
    					}
    					System.out.println(Thread.interrupted());
    				}
    			}
    		},"t1");
    		t.start();
    		t.interrupt();

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_27_color_FFFFFF_t_70 4][]

接下来是join,但是上篇我们提到join的底层是wait(),而被wait()的对象是相对于在哪里调用的那个，所以这里我们应该用main线程的interrupt()，如果有对join()不明白的可以去看上篇文章，篇头有直链。

//在join时调用interrupt()
    		final Thread main = Thread.currentThread();
    		Thread t = new Thread(new Runnable() {
    			private final Object o = new Object();
    			@Override
    			public void run() {
    				//打印当前线程是否是中断状态
    				while (true){
    				}
    			}
    		},"t1");
    		t.start();
    		Thread t2 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				main.interrupt();
    				System.out.println("t interrupt");
    			}
    		});
    		t2.start();
    		try {
    			t.join();
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_27_color_FFFFFF_t_70 5][]

[Thread_join_6]: https://blog.csdn.net/st1527960117/article/details/83184262
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_27_color_FFFFFF_t_70]: /images/20220503/b628ad54dc3444e6a3916f28c75e5c17.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_27_color_FFFFFF_t_70 1]: /images/20220503/98fc5ae709e04b999ce0c80f078f1afd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_27_color_FFFFFF_t_70 2]: /images/20220503/08eee304730f4191b39360491881f26f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_27_color_FFFFFF_t_70 3]: /images/20220503/7824848e9dcb44fabffb549c6ee45ed0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_27_color_FFFFFF_t_70 4]: /images/20220503/937be03e546a47b5a62e50f32bc431d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0MTUyNzk2MDExNw_size_27_color_FFFFFF_t_70 5]: /images/20220503/c6bea3779d7c4635b825f62815dbe96d.png