Java中interrupt的使用

通常我们会有这样的需求，即停止一个线程。在java的api中有stop、suspend等方法可以达到目的，但由于这些方法在使用上存在不安全性，会带来不好的副作用，不建议被使用。具体原因可以参考Why is Thread.stop deprecated。

在本文中，将讨论中断在java中的使用。

中断在java中主要有3个方法，interrupt(),isInterrupted()和interrupted()。

• interrupt()，在一个线程中调用另一个线程的interrupt()方法，即会向那个线程发出信号——线程中断状态已被设置。至于那个线程何去何从，由具体的代码实现决定。
• isInterrupted()，用来判断当前线程的中断状态(true or false)。
• interrupted()是个Thread的static方法，用来恢复中断状态，名字起得额🙄。

接下来，看看具体在代码中如何使用。

interrupt()不能中断在运行中的线程，它只能改变中断状态而已。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

public class InterruptionInJava implements Runnable{       public static void main(String[] args) throws InterruptedException {         Thread testThread = new Thread(new InterruptionInJava(),"InterruptionInJava");         //start thread         testThread.start();         Thread.sleep(1000);         //interrupt thread         testThread.interrupt();           System.out.println("main end");       }       @Override     public void run() {         while(true){             if(Thread.currentThread().isInterrupted()){                 System.out.println("Yes,I am interruted,but I am still running");               }else{                 System.out.println("not yet interrupted");             }         }     } }

 结果显示，被中断后，仍旧运行，不停打印Yes,I am interruted,but I am still running

那么，如何正确中断？

既然是只能修改中断状态，那么我们应该针对中断状态做些什么。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

public class InterruptionInJava implements Runnable{       public static void main(String[] args) throws InterruptedException {         Thread testThread = new Thread(new InterruptionInJava(),"InterruptionInJava");         //start thread         testThread.start(); //        Thread.sleep(1000);         //interrupt thread         testThread.interrupt();           System.out.println("main end");       }       @Override     public void run() {         while(true){             if(Thread.currentThread().isInterrupted()){                 System.out.println("Yes,I am interruted,but I am still running");                 return;               }else{                 System.out.println("not yet interrupted");             }         }     } }

修改代码，在状态判断中如上，添加一个return就okay了。但现实中，我们可能需要做的更通用，不禁又要发出天问，如何中断线程？答案是添加一个开关。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

public class InterruptionInJava implements Runnable{     private volatile static boolean on = false;     public static void main(String[] args) throws InterruptedException {         Thread testThread = new Thread(new InterruptionInJava(),"InterruptionInJava");         //start thread         testThread.start();         Thread.sleep(1000);         InterruptionInJava.on = true;           System.out.println("main end");       }       @Override     public void run() {         while(!on){             if(Thread.currentThread().isInterrupted()){                 System.out.println("Yes,I am interruted,but I am still running");             }else{                 System.out.println("not yet interrupted");             }         }     } }

会输出类似结果，这表明是成功中断了的：

这种开关的方式看起来包治百病，但是当遇到线程阻塞时，就会很无奈了，正如下面代码所示：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

public class InterruptionInJava implements Runnable{     private volatile static boolean on = false;     public static void main(String[] args) throws InterruptedException {         Thread testThread = new Thread(new InterruptionInJava(),"InterruptionInJava");         //start thread         testThread.start();         Thread.sleep(1000);         InterruptionInJava.on = true;           System.out.println("main end");       }       @Override     public void run() {         while(!on){             try {                 Thread.sleep(10000000);             } catch (InterruptedException e) {                 System.out.println("caught exception: "+e);             }         }     } }

线程被阻塞无法被中断。这时候救世主interrupt函数又回来了，它可以迅速中断被阻塞的线程，抛出一个InterruptedException，把线程从阻塞状态中解救出来,show the code。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

public class InterruptionInJava implements Runnable{     private volatile static boolean on = false;     public static void main(String[] args) throws InterruptedException {         Thread testThread = new Thread(new InterruptionInJava(),"InterruptionInJava");         //start thread         testThread.start();         Thread.sleep(1000);         InterruptionInJava.on = true;         testThread.interrupt();           System.out.println("main end");       }       @Override     public void run() {         while(!on){             try {                 Thread.sleep(10000000);             } catch (InterruptedException e) {                 System.out.println("caught exception right now: "+e);             }         }     } }

结果截图，达到预期。

这种情形同样适用io阻塞，通常io阻塞会立即抛出一个SocketException，类似于上面说的InterruptedException。