Java 并发 中断线程

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():