Java正确处理InterruptedException的方法(java并发编程第7章)

古城微笑少年丶 2022-07-12 06:59 213阅读 0赞

要想讨论正确处理InterrupedtException的方法，就要知道InterruptedException是什么。  
  
根据Java Doc的定义  
  
Thrown when a thread is waiting, sleeping, or otherwise occupied, and the thread is interrupted, either before or during the activity. Occasionally a method may wish to test whether the current thread has been interrupted, and if so, to immediately throw this exception.

意思是说当一个线程处于等待，睡眠，或者占用，也就是说阻塞状态，而这时线程被中断就会抛出这类错误,但是线程并没有被中断，任何时候，出现 该异常都需要手动在代码中再次中断该异常。Java6之后结束某个线程A的方法是A.interrupt()。如果这个线程正处于非阻塞状态，比如说线程正在执行某些代码的时候，不过被interrupt，那么该线程的interrupt变量会被置为true，告诉别人说这个线程被中断了（只是一个标志位，这个变量本身并不影响线程的中断与否），而且线程会被中断，这时不会有interruptedException。但如果这时线程被阻塞了，比如说正在睡眠，那么就会抛出这个错误。请注意，这个时候变量interrupt没有被置为true,而且也没有人来中断这个线程。这类阻塞操作中中断线程，需要做如下操作。

在java的中断机制中, InterruptedException异常占据重要的位置. 处理InterruptedException异常的方式有:

1. 不catch直接向上层抛出, 或者catch住做一些清理工作之后重抛该异常. 这样的处理使得你的方法也成为一个可中断的阻塞方法:

Java代码   ![收藏代码][icon_star.png]

1.  // 直接向上层抛出InterruptedException, dosomething方法也是一个可中断的阻塞方法  
2.  **private** **void** dosomething() **throws** InterruptedException \{  
3.      Thread.sleep(1000);  
4.  \}

2. 有时不能向上抛出InterruptedException异常(例如父类的相应方法没有声明该异常), 此时catch之后, 必须设置当前线程的中断标记为true, 以表明当前线程发生了中断, 以便调用栈上层进行处理:

Java代码   ![收藏代码][icon_star.png]

1.  **public** **class** InterruptedExceptionHandler **implements** Runnable \{  
2.      **private** Object lock = **new** Object();  
3.    
4.      @Override  
5.      **public** **void** run() \{  
6.          **while** (!Thread.currentThread().isInterrupted()) \{  
7.              dosomething();  
8.          \}  
9.      \}  
10.   
11.     **private** **void** dosomething() \{  
12.         **try** \{  
13.             // Object.wait是一个可中断的阻塞方法, 如果在其阻塞期间检查到当前线程的中断标记为true, 会重置中断标记后从阻塞状态返回, 并抛出InterruptedException异常  
14.             **synchronized** (lock) \{  
15.                 lock.wait();  
16.             \}  
17.         \} **catch** (InterruptedException e) \{  
18.             System.out.println("InterruptedException happened");  
19.             // catch住InterruptedException后设置当前线程的中断标记为true, 以供调用栈上层进行相应的处理  
20.             // 在此例中, dosomething方法的调用栈上层是run方法.  
21.             Thread.currentThread().interrupt();  
22.         \}  
23.     \}  
24.       
25.     **public** **static** **void** main(String\[\] args) **throws** InterruptedException \{  
26.         Thread t = **new** Thread(**new** InterruptedExceptionHandler());  
27.         t.start();  
28.         // 启动线程1s后设置其中断标记为true  
29.         Thread.sleep(1000);  
30.         t.interrupt();  
31.     \}  
32. \}

主线程启动InterruptedExceptionHandler线程1s后, 设置InterruptedExceptionHandler线程的中断标记为true. 此时InterruptedExceptionHandler线程应该阻塞在wait方法上, 由于wait方法是可中断的阻塞方法, 所以其检查到中断标记为true时, 将重置当前线程的中断标记后抛出InterruptedException, dosomething方法catch住InterruptedException异常后, 再次将当前线程的中断标记设置为true, run方法检查到中断标记为true, 循环不再继续. 假如dosomething方法catch住InterruptedException异常后没有设置中断标记, 其调用栈上层的run方法就无法得知线程曾经发生过中断, 循环也就无法终止.

3. 还有一种情形比较特殊: 我们希望发生了InterruptedException异常后仍然继续循环执行某阻塞方法, 此时应该将中断状态保存下来, 当循环完成后再根据保存下来的中断状态执行相应的操作:

Java代码   ![收藏代码][icon_star.png]

1.  **public** **class** InterruptedExceptionContinueHandler **implements** Runnable \{  
2.      **private** BlockingQueue<Integer> queue;  
3.    
4.      **public** InterruptedExceptionContinueHandler(BlockingQueue<Integer> queue) \{  
5.          **this**.queue = queue;  
6.      \}  
7.    
8.      @Override  
9.      **public** **void** run() \{  
10.         **while** (!Thread.currentThread().isInterrupted()) \{  
11.             dosomething();  
12.         \}  
13.         System.out.println(queue.size());  
14.     \}  
15.   
16.     **private** **void** dosomething() \{  
17.         // cancelled变量用于表明线程是否发生过中断  
18.         **boolean** cancelled = **false**;  
19.         **for** (**int** i = 0; i < 10000; i++) \{  
20.             **try** \{  
21.                 queue.put(i);  
22.             \} **catch** (InterruptedException e) \{  
23.                 // 就算发生了InterruptedException, 循环也希望继续运行下去, 此时将cancelled设置为true, 以表明遍历过程中发生了中断  
24.                 System.out.println("InterruptedException happened when i = " + i);  
25.                 cancelled = **true**;  
26.             \}  
27.         \}  
28.         // 如果当前线程曾经发生过中断, 就将其中断标记设置为true, 以通知dosomething方法的上层调用栈  
29.         **if** (cancelled) \{  
30.             Thread.currentThread().interrupt();  
31.         \}  
32.     \}  
33.       
34.     **public** **static** **void** main(String\[\] args) **throws** InterruptedException \{  
35.         Thread t = **new** Thread(**new** InterruptedExceptionContinueHandler(**new** LinkedBlockingQueue<Integer>()));  
36.         t.start();  
37.           
38.         // 启动线程2ms后设置其中断标记为true  
39.         Thread.sleep(2);  
40.         t.interrupt();  
41.     \}  
42. \}

在我的机器中, 输出结果如下:

InterruptedException happened when i = 936

size = 9999

队列的size是9999而不是10000, 是因为i = 936时发生了InterruptedException异常, 该次put没有成功.

为什么不在发生InterruptedException时就设置当前线程的中断标记, 而非要绕一圈? 假设将dosomething方法改为:

Java代码   ![收藏代码][icon_star.png]

1.  **private** **void** dosomething() \{  
2.      **for** (**int** i = 0; i < 10000; i++) \{  
3.          **try** \{  
4.              queue.put(i);  
5.          \} **catch** (InterruptedException e) \{  
6.              System.out.println("InterruptedException happened when i = " + i);  
7.              Thread.currentThread().interrupt();  
8.          \}  
9.      \}  
10. \}

运行后发现结果类似为:

InterruptedException happened when i = 936

InterruptedException happened when i = 937

...

InterruptedException happened when i = 9998

InterruptedException happened when i = 9999

size = 936

catch住InterruptedException后立即将当前线程的中断标记设置为true, 就会导致put方法又抛出InterruptedException异常, 如此往复直到循环结束.

4. 最不可取的是catch了InterruptedException异常但是不做任何处理, 这样一来调用栈上层就无法得知当前线程是否发生过中断. 只有一种情况下可以这样处理: 当InterruptedException发生在调用栈的最上层, 如run方法, 或者main方法中, 且后续代码不检查中断状态时:

Java代码   ![收藏代码][icon_star.png]

1.  **public** **static** **void** main(String\[\] args) \{  
2.      // main方法已经是调用栈的最上层, 此时可以catchInterruptedException后不做任何处理  
3.      **try** \{  
4.          Thread.sleep(2);  
5.      \} **catch** (InterruptedException e) \{  
6.          e.printStackTrace();  
7.      \}  
8.  \}

[icon_star.png]: /images/20220711/6cb36f6f3e1241ef9a000002f1f072b9.png