Java 并发中断线程

@author ixenos

对Runnable.run()方法的三种处置情况

1.在Runnable.run()方法的中间中断它

2.等待该方法到达对cancel标志的测试（用一个if+标志变量）

3.等待该方法到达程序员准备好离开的地方

　　第一种情况比其他两种难以处置，因为当打断一个被阻塞的任务时，可能需要清理资源。

　　因此，在任务的run()方法中间打断，就像是抛出的异常，在“catch异常处理”中清理资源（否则不放锁），于是Java也为这种打断使用了异常机制。

可中断阻塞和不可中断阻塞

1.SleepBlock 是可中断的阻塞

2.IOBlocked 和 SynchronizedBlocked 是不可中断的阻塞（I/O和synchronized方法都不需要InterruptedException处理器）

示例：

  1 // Interrupting a blocked thread.
  2 import java.util.concurrent.*;
  3 import java.io.*;
  4 import static net.mindview.util.Print.*;
  5 
  6 /*
  7     SleepBlock
  8 
  9 */
 10 class SleepBlocked implements Runnable {
 11   public void run() {
 12     try {
 13       TimeUnit.SECONDS.sleep(100);
 14     } catch(InterruptedException e) {
 15       print("InterruptedException");
 16     }
 17     print("Exiting SleepBlocked.run()");
 18   }
 19 }
 20 
 21 
 22 /*
 23     IOBlock
 24 */
 25 class IOBlocked implements Runnable {
 26   private InputStream in;
 27   public IOBlocked(InputStream is) { in = is; }
 28   public void run() {
 29     try {
 30       print("Waiting for read():");
 31       in.read();
 32     } catch(IOException e) {
 33       if(Thread.currentThread().isInterrupted()) {
 34         print("Interrupted from blocked I/O");
 35       } else {
 36         throw new RuntimeException(e);
 37       }
 38     }
 39     print("Exiting IOBlocked.run()");
 40   }
 41 }
 42 
 43 
 44 /*
 45       SynchronizedBlock
 46 
 47 */
 48 class SynchronizedBlocked implements Runnable {
 49   public synchronized void f() {
 50     while(true) // Never releases lock
 51       Thread.yield();
 52   }
 53   public SynchronizedBlocked() {
 54     new Thread() {
 55       public void run() {
 56         f(); // Lock acquired by this thread
 57       }
 58     }.start();
 59   }
 60   public void run() {
 61     print("Trying to call f()");
 62     f();
 63     print("Exiting SynchronizedBlocked.run()");
 64   }
 65 }
 66 
 67 
 68 public class Interrupting {
 69   //用java.util.concurrent.*包中的Executor来统一管理多个线程
 70   private static ExecutorService exec =
 71     Executors.newCachedThreadPool();
 72 
 73   static void test(Runnable r) throws InterruptedException{
 74     /*
 75           submit() 启动任务将返回Future<?>，
 76           可以调用cancel来调用interrupt方法中断某个特定任务；
 77           executor() 启动任务，
 78           只能调用shutdownNow()来中断所有任务。
 79     */
 80     Future<?> f = exec.submit(r);
 81     TimeUnit.MILLISECONDS.sleep(100);
 82     print("Interrupting " + r.getClass().getName());
 83 
 84     
 85     f.cancel(true); // Interrupts if running
 86     print("Interrupt sent to " + r.getClass().getName());
 87   }
 88 
 89   //main方法
 90   public static void main(String[] args) throws Exception {
 91     test(new SleepBlocked());
 92     test(new IOBlocked(System.in));
 93     test(new SynchronizedBlocked());
 94     TimeUnit.SECONDS.sleep(3);
 95     print("Aborting with System.exit(0)");
 96     System.exit(0); // ... since last 2 interrupts failed
 97   }
 98 } /* Output: (95% match)
 99 Interrupting SleepBlocked
100 InterruptedException
101 Exiting SleepBlocked.run()
102 Interrupt sent to SleepBlocked
103 Waiting for read():
104 Interrupting IOBlocked
105 Interrupt sent to IOBlocked
106 Trying to call f()
107 Interrupting SynchronizedBlocked
108 Interrupt sent to SynchronizedBlocked
109 Aborting with System.exit(0)
110 *///:~

中断线程

1.Thread类包含interrupt()方法，可以终止被阻塞的任务，这个方法将设置线程的中断状态

　　1）如果一个线程已被阻塞或试图执行一个阻塞操作时，调用interrupt设置这个线程的中断状态，将抛出InterruptedException

　　2）当抛出InterruptedException 或该任务调用Thread.interrupted()时，中断状态将被复位为 false (但实际已中断~)。

- - 可见，使用Thread.interrupted() 既离开run()循环中断线程，又不抛出InterruptedException

2.中断状态：中断状态是每一个线程都具有的boolean标志，（建议每个线程都应该不时地检查这个标志，以判断线程是否被中断）

　　1）t.interrupt(): 当对一个线程调用interrupt()方法时，线程的中断状态将被置位

　　2）Thread.interrupted():