Java 7 Concurrency Cookbook 翻译 第一章 线程管理之二

Posted 2020-08-19

三、中断一个线程

　　一个拥有多个线程的Java程序要结束，需要满足两个条件之一：一是所有的非后台线程都执行结束了；二是某个线程执行了 System.exit() 方法。当你想要终结一个运行中的Java程序或者程序的用户想要取消一个线程正在执行的任务时，你都需要结束一个线程。

　　Java提供中断机制来表明我们想要终止一个线程。这个机制的核心是线程必须要检查自己是否被中断，而且线程自己决定是否响应中断请求。线程可以忽略该中断请求而继续执行。

　　在本秘诀中，我们将开发一个程序，这个程序创建线程，5秒后使用中断机制来结束线程。

public class Main {
    public static void main(String[] args) {
        Thread task = new PrimeGenerator();
        task.start();
        
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        task.interrupt();
    }
}

public class PrimeGenerator extends Thread {

    @Override
    public void run() {
        long number = 1L;
        while (true) {
            if (isPrime(number)) {
                System.out.printf("Number "+ number +" is Prime");
            }
            
            if (isInterrupted()) {
                System.out.printf("The Prime Generator has been Interrupted");
                return;
            }
            number++;
        }
    }
    
    private boolean isPrime(long number) {
        if (number <= 2) {
            return true;
        }
        for (long i = 2; i < number; i++) {
            if ((number % i) == 0) {
                return false;
            }
        }
        return true;
    }
}

　　在 Thread 类中有一个 boolean 类型的属性来表明该类对应的线程是否被中断。通过调用 Thread 对象的 interrupt() 方法，设置其对应的线程被中断。而 isInterrupted() 方法用来返回对应线程是否被中断的状态。

　　Thread 类还有一个静态方法 interrupted() 同样可以返回所在线程是否被中断的状态。但是该方法还有一个副作用：就是把线程的被中断状态重设为 false。

　　线程可以忽略其被中断的状态，但这通常不是好的编程习惯。

四、控制线程的中断状态

　　在上一个秘诀中，你学习了如何去中断一个线程和如何去控制线程的中断状态。如果你要中断执行的只是一个简单的线程，那么上一个秘诀就足够了。但是，如果该线程实现了一个分成多个方法的复杂算法，或者它含有实现了递归算法的方法，我们应该使用一种更好的机制去该线程的中断状态。为此，Java提供了 InterruptedException。当你在 run() 方法里发现了线程被中断时，你可以抛出并捕获该异常。

　　在本秘诀中，我们的线程在目录和其子目录中来寻找含有特定名称的文件，这个程序展示如何使用 InterruptedException 来控制线程的中断。

public class FileSearch implements Runnable{
    private String initPath;
    private String fileName;
    public FileSearch(String initPath, String fileName) {
        this.initPath = initPath;
        this.fileName = fileName;
    }
    @Override
    public void run() {
        File file = new File(initPath);
        if (file.isDirectory()) {
            try {
                directoryProcess(file);
            } catch (InterruptedException e) {
                System.out.printf("%s: The search has been "
                        + "interrupted", Thread.currentThread().getName());
            }
        }
    }
    
    private void directoryProcess(File file) throws InterruptedException {
        File list[] = file.listFiles();
        if (list != null) {
            for (int i = 0; i < list.length; i++) {
                if (list[i].isDirectory()) {
                    directoryProcess(list[i]);
                } else {
                    fileProcess(list[i]);
                }
            }
        }
        if (Thread.interrupted()) {
            throw new InterruptedException();
        }
    }
    
    private void fileProcess(File file) throws InterruptedException {
        if (file.getName().equals(fileName)) {
            System.out.printf("%s : %s\\n", Thread.currentThread().getName(), 
                    file.getAbsolutePath());
        }
        if (Thread.interrupted()) {
            throw new InterruptedException();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        FileSearch search = new FileSearch("C:\\\\", "autoexec.bat");
        Thread thread = new Thread(search);
        thread.start();
        
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        thread.interrupt();
    }
}

　　在这个例子中，我们使用异常机制来达到终止线程运行的目的。你运行此示例程序，程序开始遍历目录并查找特定的文件。一旦线程检查到自己被中断了，它就抛出 InterruptedException 异常，继续执行 run() 方法的代码，多层的递归调用对结果没实质影响。

　　Java并发API中的 sleep() 方法也有可能抛出 InterruptedException异常。

　　笔者总结：本秘诀本质还是线程自己检查是否被中断，发现被中断后，通过抛出异常的方式直接跳转到了异常捕获代码处，是否多层递归对此异常跳转机制没影响。

　　重要：本系列翻译文档也会在本人的微信公众号(此山是我开)第一时间发布，欢迎大家关注。