前文从任务到线程：Java结构化并发应用程序中介绍了如何安排任务启动线程。
线程在启动之后，正常的情况下会运行到任务完成，但是有的情况下会需要提前结束任务，如用户取消操作等。可是，让线程安全、快速和可靠地停止并不是件容易的事情，因为Java中没有提供安全的机制来终止线程。虽然有Thread.stop/suspend等方法，但是这些方法存在缺陷，不能保证线程中共享数据的一致性，所以应该避免直接调用。

线程在终止的过程中，应该先进行操作来清除当前的任务，保持共享数据的一致性，然后再停止。

庆幸的是，Java中提供了中断机制，来让多线程之间相互协作，由一个进程来安全地终止另一个进程。

1. 任务的取消

如果外部的代码能在某个操作正常完成之前将其设置为完成状态，则该操作为可取消的（Cancellable）。

操作被取消的原因有很多，比如超时，异常，请求被取消等等。

一个可取消的任务要求必须设置取消策略，即如何取消，何时检查取消命令，以及接收到取消命令之后如何处理。

最简单的取消办法就是利用取消标志位，如下所示：

public class PrimeGenerator implements Runnable {
    private static ExecutorService exec = Executors.newCachedThreadPool();
    private final List<BigInteger> primes
            = new ArrayList<BigInteger>();
    //取消标志位
    private volatile boolean cancelled;
    public void run() {
        BigInteger p = BigInteger.ONE;
        //每次在生成下一个素数时坚持是否取消
        //如果取消，则退出
        while (!cancelled) {
            p = p.nextProbablePrime();
            synchronized (this) {
                primes.add(p);
            }
        }
    }
    public void cancel() {
        cancelled = true;
    }
    public synchronized List<BigInteger> get() {
        return new ArrayList<BigInteger>(primes);
    }
    static List<BigInteger> aSecondOfPrimes() throws InterruptedException {
        PrimeGenerator generator = new PrimeGenerator();
        exec.execute(generator);
        try {
            SECONDS.sleep(1);
        } finally {
            generator.cancel();
        }
        return generator.get();
    }
}

这段代码用于生成素数，并在任务运行一秒钟之后终止。其取消策略为：通过改变取消标志位取消任务，任务在每次生成下一随机素数之前检查任务是否被取消，被取消后任务将退出。

然而，该机制的最大的问题就是无法应用于拥塞方法。假设在循环中调用了拥塞方法，任务可能因拥塞而永远不会去检查取消标志位，甚至会造成永远不能停止。

1.1 中断

为了解决拥塞方法带来的问题，就需要使用中断机制来取消任务。

虽然在Java规范中，线程的取消和中断没有必然联系，但是在实践中发现：中断是取消线程的最合理的方式。

Thread类中和中断相关的方法如下：

public class Thread {
    // 中断当前线程
    public void interrupt();
    // 判断当前线程是否被中断
    public boolen isInterrupt();
    // 清除当前线程的中断状态，并返回之前的值
    public static boolen interrupt();   
}

调用Interrupt方法并不是意味着要立刻停止目标线程，而只是传递请求中断的消息。所以对于中断操作的正确理解为：正在运行的线程收到中断请求之后，在下一个合适的时刻中断自己。

使用中断方法改进素数生成类如下：

public class PrimeProducer extends Thread {
    private final BlockingQueue<BigInteger> queue;
    PrimeProducer(BlockingQueue<BigInteger> queue) {
        this.queue = queue;
    }
    public void run() {
        try {
            BigInteger p = BigInteger.ONE;
            //使用中断的方式来取消任务
            while (!Thread.currentThread().isInterrupted())
                //put方法会隐式检查并响应中断
                queue.put(p = p.nextProbablePrime());
        } catch (InterruptedException consumed) {
            /* 允许任务退出 */
        }
    }
    public void cancel() {
        interrupt();
    }
}

代码中有两次检查中断请求：

• 第一次是在循环开始前，显示检查中断请求；
• 第二次是在put方法，该方法为拥塞的，会隐式坚持当前线程是否被中断；

1.2 中断策略

和取消策略类似，可以被中断的任务也需要有中断策略:
即如何中断，合适检查中断请求，以及接收到中断请求之后如何处理。

由于每个线程拥有各自的中断策略，因此除非清楚中断对目标线程的含义，否者不要中断该线程。

正是由于以上原因，大多数拥塞的库函数在检测到中断都是抛出中断异常（InterruptedException）作为中断响应，让线程的所有者去处理，而不是去真的中断当前线程。

虽然有人质疑Java没有提供抢占式的中断机制，但是开发人员通过处理中断异常的方法，可以定制更为灵活的中断策略，从而在响应性和健壮性之间做出合理的平衡。

一般情况的中断响应方法为：

1. 传递异常：收到中断异常之后，直接将该异常抛出；
2. 回复中断状态：即再次调用Interrupt方法，恢复中断状态，让调用堆栈的上层能看到中断状态进而处理它。

切记，只有实现了线程中断策略的代码才能屏蔽中断请求，在常规的任务和库代码中都不应该屏蔽中断请求。中断请求是线程中断和取消的基础。

1.3 定时运行

定时运行一个任务是很常见的场景，很多问题是很费时间的，就需在规定时间内完成，如果没有完成则取消任务。

以下代码就是一个定时执行任务的实例：

public class TimedRun1 {
    private static final ScheduledExecutorService cancelExec = Executors.newScheduledThreadPool(1);
    public static void timedRun(Runnable r,
                                long timeout, TimeUnit unit) {
        final Thread taskThread = Thread.currentThread();
        cancelExec.schedule(new Runnable() {
            public void run() {
                // 中断线程，
                // 违规，不能在不知道中断策略的前提下调用中断，
                // 该方法可能被任意线程调用。
                taskThread.interrupt();
            }
        }, timeout, unit);
        r.run();
    }
}

很可惜，这是反面的例子，因为timedRun方法在不知道Runnable对象的中断策略的情况下，就中断该任务，这样会承担很大的风险。而且如果Runnable对象不支持中断， 则该定时模型就会失效。

为了解决上述问题，就需要执行任务都线程有自己的中断策略，如下：

public class LaunderThrowable {
    public static RuntimeException launderThrowable(Throwable t) {
        if (t instanceof RuntimeException)
            return (RuntimeException) t;
        else if (t instanceof Error)
            throw (Error) t;
        else
            throw new IllegalStateException("Not unchecked", t);
    }
}
public class TimedRun2 {
    private static final ScheduledExecutorService cancelExec = newScheduledThreadPool(1);
    public static void timedRun(final Runnable r,
                                long timeout, TimeUnit unit)
            throws InterruptedException {
        class RethrowableTask implements Runnable {
            private volatile Throwable t;
            public void run() {
                try {
                    r.run();
                } catch (Throwable t) {
                    //中断策略，保存当前抛出的异常，退出
                    this.t = t;
                }
            }
            // 再次抛出异常
            void rethrow() {
                if (t != null)
                    throw launderThrowable(t);
            }
        }
        RethrowableTask task = new RethrowableTask();
        final Thread taskThread = new Thread(task);
        //开启任务子线程
        taskThread.start();
        //定时中断任务子线程
        cancelExec.schedule(new Runnable() {
            public void run() {
                taskThread.interrupt();
            }
        }, timeout, unit);
        //限时等待任务子线程执行完毕
        taskThread.join(unit.toMillis(timeout));
        //尝试抛出task在执行中抛出到异常
        task.rethrow();
    }
}

无论Runnable对象是否支持中断，RethrowableTask对象都会记录下来发生的异常信息并结束任务，并将该异常再次抛出。

1.4 通过Future取消任务

Future用来管理任务的生命周期，自然也可以来取消任务，调用Future.cancel方法就是用中断请求结束任务并退出，这也是Executor的默认中断策略。

用Future实现定时任务的代码如下：

public class TimedRun {
    private static final ExecutorService taskExec = Executors.newCachedThreadPool();
    public static void timedRun(Runnable r,
                                long timeout, TimeUnit unit)
            throws InterruptedException {
        Future<?> task = taskExec.submit(r);
        try {
            task.get(timeout, unit);
        } catch (TimeoutException e) {
            // 因超时而取消任务
        } catch (ExecutionException e) {
            // 任务异常，重新抛出异常信息
            throw launderThrowable(e.getCause());
        } finally {
            // 如果该任务已经完成，将没有影响
            // 如果任务正在运行，将因为中断而被取消
            task.cancel(true); // interrupt if running
        }
    }
}

1.5 不可中断的拥塞

一些的方法的拥塞是不能响应中断请求的，这类操作以I/O操作居多，但是可以让其抛出类似的异常，来停止任务：

• Socket I/O: 关闭底层socket，所有因执行读写操作而拥塞的线程会抛出SocketException；
• 同步 I/O：大部分Channel都实现了InterruptiableChannel接口，可以响应中断请求，抛出异常ClosedByInterruptException;
• Selector的异步 I/O：Selector执行select方法之后，再执行close和wakeUp方法就会抛出异常ClosedSelectorException。

以套接字为例，其利用关闭socket对象来响应异常的实例如下：

public class ReaderThread extends Thread {
    private static final int BUFSZ = 512;
    private final Socket socket;
    private final InputStream in;
    public ReaderThread(Socket socket) throws IOException {
        this.socket = socket;
        this.in = socket.getInputStream();
    }
    public void interrupt() {
        try {
            // 关闭套接字
            // 此时in.read会抛出异常
            socket.close();
        } catch (IOException ignored) {
        } finally {
            // 正常的中断
            super.interrupt();
        }
    }
    public void run() {
        try {
            byte[] buf = new byte[BUFSZ];
            while (true) {
                int count = in.read(buf);
                if (count < 0)
                    break;
                else if (count > 0)
                    processBuffer(buf, count);
            }
        } catch (IOException e) { 
            // 如果socket关闭，in.read方法将会抛出异常
            // 借此机会，响应中断，线程退出
        }
    }
    public void processBuffer(byte[] buf, int count) {
    }
}