Thread interrupt方法解析

初步理解

我们在看一些多线程代码的时候，有的时候会碰到使用interrupt()方法的时候。从字面的意思来理解，应该就是中断当前正在执行的线程。那么，对于一个我们设计的普通线程来说，如果我们在主线程里调用它的interrupt()方法，会不会导致它被中断呢？

比如说我们先写一段如下的代码：

1. import java.util.concurrent.TimeUnit;
2. public class ThreadCon extends Thread
3. {
4. public void run()
5. {
6. for(int i = 0; i < Integer.MAX_VALUE; i++)
7. {
8. System.out.println(i);
9. }
10. }
11. public static void main(String[] args)
12. {
13. ThreadCon thread = new ThreadCon();
14. thread.start();
15. System.out.println("main thread");
16. try
17. {
18. TimeUnit.SECONDS.sleep(2);
19. }
20. catch(InterruptedException e)
21. {
22. e.printStackTrace();
23. }
24. thread.interrupt();
25. }
26. }

这是一段比较简单的示例，我们在开始的时候启动一个子线程，这个线程打印从0到Integer.MAX_VALUE 的值。而主线程先sleep 2秒钟。然后再尝试去中断子线程。

如果我们去运行前面这一段代码，会发现子线程会一直在输出数字结果，它根本就不会停下来。部分结果的输出如下：

1. 141318
2. 141319
3. 141320
4. 141321
5. 141322
6. 141323
7. 141324
8. 141325

由此可见，我们对一个子线程发interrupt的消息时，如果线程是在运行的状态之下，它会忽略这个请求而继续执行的。

那么，在什么情况下才会导致这个触发的interrupt消息让子线程能够响应呢？

interrupt方法处理方式

interrupt方法调用的时候会设置该线程的interrupt标识位(flag)，相当于设置了一个状态信息。执行的子线程需要检查该标识位是否被设置了然后才能做后续的执行步骤。这个检查的方法就是isInterrupted()。这样，在一旦检测到这个位被设置之后，我们就可以采取对应的措施。

我们在前面的代码的基础上做一点修改：

1. import java.util.concurrent.TimeUnit;
2. public class ThreadCon extends Thread
3. {
4. public void run()
5. {
6. for(int i = 0; i < Integer.MAX_VALUE; i++)
7. {
8. System.out.println(i);
9. if(isInterrupted())
10. {
11. System.out.println("Interrupted...");
12. return;
13. }
14. }
15. }
16. public static void main(String[] args)
17. {
18. ThreadCon thread = new ThreadCon();
19. thread.start();
20. System.out.println("main thread");
21. try
22. {
23. TimeUnit.SECONDS.sleep(2);
24. }
25. catch(InterruptedException e)
26. {
27. e.printStackTrace();
28. }
29. thread.interrupt();
30. }
31. }

这里，我们在run方法的循环里增加了一个判断，调用isInterrupted方法。如果被设置为interrupted，则显示一个信息然后退出。这个时候如果我们再执行这部分代码，会发现结果如下：

1. 141370
2. 141371
3. 141372
4. 141373
5. 141374
6. 141375
7. 141376
8. 141377
9. 141378
10. Interrupted...

所以说，从前面的代码中可以看到，这是一种处理interrupt方法的手段。在实际的一些应用中，我们可以通过抛出异常然后由调用程序捕捉的方式来处理。比如在前面的这个示例里，我们判断了isInterrupted了之后就在接着的部分处理了。如果我们希望由调用该方法的使用者来处理。可以在这里不做进一步的处理而是直接写一个throw new InterruptedException()。

这里也有一个稍微复杂点的示例，通过遍历文件系统，然后在处理的子方法里面来抛出异常，再由调用的方法来处理。

1. import java.io.File;
2. public class FileSearch implements Runnable {
3. private String initPath;
4. private String fileName;
5. public FileSearch(String initPath, String fileName) {
6. this.initPath = initPath;
7. this.fileName = fileName;
8. }
9. @Override
10. public void run() {
11. File file = new File(initPath);
12. if(file.isDirectory()) {
13. try {
14. directoryProcess(file);
15. } catch(InterruptedException e) {
16. System.out.printf("%s: The search has been interrupted",
17. Thread.currentThread().getName());
18. }
19. }
20. }
21. private void directoryProcess(File file) throws InterruptedException {
22. File[] list = file.listFiles();
23. if(list != null) {
24. for(int i = 0; i < list.length; i++) {
25. if(list[i].isDirectory()) {
26. directoryProcess(list[i]);
27. } else {
28. fileProcess(list[i]);
29. }
30. }
31. }
32. if(Thread.interrupted()) {
33. throw new InterruptedException();
34. }
35. }
36. private void fileProcess(File file) throws InterruptedException {
37. if(file.getName().equals(fileName)) {
38. System.out.printf("%s : %s\n", Thread.currentThread().getName(),
39. file.getAbsolutePath());
40. }
41. if(Thread.interrupted()) {
42. throw new InterruptedException();
43. }
44. }
45. }

启用该线程的部分代码如下：

1. import java.util.concurrent.TimeUnit;
2. /**
3. *  Main class of the example. Search for the autoexect.bat file
4. *  on the Windows root folder and its subfolders during ten seconds
5. *  and then, interrupts the Thread
6. */
7. public class Main {
8. /**
9. * Main method of the core. Search for the autoexect.bat file
10. * on the Windows root folder and its subfolders during ten seconds
11. * and then, interrupts the Thread
12. * @param args
13. */
14. public static void main(String[] args) {
15. // Creates the Runnable object and the Thread to run it
16. FileSearch searcher=new FileSearch("C:\\","autoexec.bat");
17. Thread thread=new Thread(searcher);
18. // Starts the Thread
19. thread.start();
20. // Wait for ten seconds
21. try {
22. TimeUnit.SECONDS.sleep(10);
23. } catch (InterruptedException e) {
24. e.printStackTrace();
25. }
26. // Interrupts the thread
27. thread.interrupt();
28. }
29. }

总结

interrupt方法的效果是它会设置线程的状态位，但是对于正在运行状态的线程并不会导致它被立即中断。只有执行的线程在检测到相关信息后采取对应措施。我们常用的措施一般是调用isInterrupted方法或者捕捉被调用方法抛出的InterruptedException来做处理。整体的应用并不复杂。