摘要：比如上一篇文章提到的線程池的方法，它可以在線程池中運行一組任務，當其中任何一個任務完成時，方法便會停止阻塞并返回，同時也會取消其他任務。

當一個任務正在運行的過程中，而我們卻發現這個任務已經沒有必要繼續運行了，那么我們便產生了取消任務的需要。比如 上一篇文章 提到的線程池的 invokeAny 方法，它可以在線程池中運行一組任務，當其中任何一個任務完成時，invokeAny 方法便會停止阻塞并返回，同時也會 取消其他任務。那我們如何取消一個正在運行的任務？

前面兩篇多線程的文章都有提到 Future 接口和它的一個實現類 FutureTask，并且我們已經知道 Future 可以用來和已經提交的任務進行交互。Future 接口定義了如下幾個方法：

get 方法：通過前面文章的介紹，我們已經了解了 get 方法的使用 —— get 方法 用來返回和 Future 關聯的任務的結果。帶參數的 get 方法指定一個超時時間，在超時時間內該方法會阻塞當前線程，直到獲得結果 。

如果在給定的超時時間內沒有獲得結果，那么便拋出 TimeoutException 異常；

或者執行的任務被取消（此時拋出 CancellationException 異常）；

或者執行任務時出錯，即執行過程中出現異常（此時拋出 ExecutionException 異常）；

或者當前線程被中斷（此時拋出 InterruptedException 異常 —— 注意，當前線程是指調用 get 方法的線程，而不是運行任務的線程）。

不帶參數的 get 可以理解為超時時間無限大，即一直等待直到獲得結果或者出現異常。

cancel(boolean mayInterruptIfRunning) 方法：該方法是非阻塞的。通過 JDK 的文檔，我們可以知道 該方法便可以用來（嘗試）終止一個任務。

如果任務運行之前調用了該方法，那么任務就不會被運行；

如果任務已經完成或者已經被取消，那么該方法方法不起作用；

如果任務正在運行，并且 cancel 傳入參數為 true，那么便會去終止與 Future 關聯的任務。

cancel(false) 與 cancel(true）的區別在于，cancel(false) 只 取消已經提交但還沒有被運行的任務（即任務就不會被安排運行）；而 cancel(true) 會取消所有已經提交的任務，包括 正在等待的 和 正在運行的 任務。

isCancelled 方法：該方法是非阻塞的。在任務結束之前，如果任務被取消了，該方法返回 true，否則返回 false；如果任務已經完成，該方法則一直返回 false。

isDone 方法：該方法同樣是非阻塞的。如果任務已經結束（正常結束，或者被取消，或者執行出錯），返回 true，否則返回 false。

然后我們來實踐下 Future 的 cancel 方法的功能：

import java.util.concurrent.*;

public class FutureTest {

    public static void main(String[] args) throws Exception {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();

        SimpleTask task = new SimpleTask(3_000); // task 需要運行 3 秒
        Future future = threadPool.submit(task);
        threadPool.shutdown(); // 發送關閉線程池的指令

        double time = future.get();
        System.out.format("任務運行時間: %.3f s
", time);

    }

    private static final class SimpleTask implements Callable {

        private final int sleepTime; // ms

        public SimpleTask(int sleepTime) {
            this.sleepTime = sleepTime;
        }

        @Override
        public Double call() throws Exception {
            double begin = System.nanoTime();

            Thread.sleep(sleepTime);

            double end = System.nanoTime();
            double time = (end - begin) / 1E9;

            return time; // 返回任務運行的時間，以 秒 計
        }

    }
}

運行結果（任務正常運行）：

然后我們定義一個用來取消任務的方法：

private static void cancelTask(final Future future, final int delay) {

    Runnable cancellation = new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(delay);
                future.cancel(true); // 取消與 future 關聯的正在運行的任務
            } catch (InterruptedException ex) {
                ex.printStackTrace(System.err);
            }
        }
    };

    new Thread(cancellation).start();
}

然后修改 main 方法：

public static void main(String[] args) {
    ExecutorService threadPool = Executors.newSingleThreadExecutor();

    SimpleTask task = new SimpleTask(3_000); // task 需要運行 3 秒
    Future future = threadPool.submit(task);
    threadPool.shutdown(); // 發送關閉線程池的指令

    cancelTask(future, 2_000); // 在 2 秒之后取消該任務

    try {
        double time = future.get();
        System.out.format("任務運行時間: %.3f s
", time);
    } catch (CancellationException ex) {
        System.err.println("任務被取消");
    } catch (InterruptedException ex) {
        System.err.println("當前線程被中斷");
    } catch (ExecutionException ex) {
        System.err.println("任務執行出錯");
    }

}

運行結果：

可以看到，當任務被取消時，Future 的 get 方法拋出了 CancellationException 異常，并且成功的取消了任務（從構建（運行）總時間可以發現）。

這樣就可以了嗎？調用 Future 的 cancel(true) 就一定能取消正在運行的任務嗎？

我們來寫一個真正的耗時任務，判斷一個數是否為素數，測試數據為 1000000033 （它是一個素數）。

import java.util.concurrent.*;

public class FutureTest {

    public static void main(String[] args) throws Exception {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();

        long num = 1000000033L;
        PrimerTask task = new PrimerTask(num);
        Future future = threadPool.submit(task);
        threadPool.shutdown();
        
        boolean result = future.get();
        System.out.format("%d 是否為素數？ %b
", num, result);

    }

    private static final class PrimerTask implements Callable {

        private final long num;

        public PrimerTask(long num) {
            this.num = num;
        }

        @Override
        public Boolean call() throws Exception {
            // i < num 讓任務有足夠的運行時間
            for (long i = 2; i < num; i++) {
                if (num % i == 0) {
                    return false;
                }
            }

            return true;
        }

    }

}

在我的機器上，這個任務需要 13 秒才能運行完畢：

然后我們修改 main 方法，在任務運行到 2 秒的時候調用 Future 的 cancel(true) ：

public static void main(String[] args) throws Exception {
    ExecutorService threadPool = Executors.newSingleThreadExecutor();

    long num = 1000000033L;
    PrimerTask task = new PrimerTask(num);
    Future future = threadPool.submit(task);
    threadPool.shutdown(); // 發送關閉線程池的指令

    cancelTask(future, 2_000); // 在 2 秒之后取消該任務

    try {
        boolean result = future.get();
        System.out.format("%d 是否為素數？ %b
", num, result);
    } catch (CancellationException ex) {
        System.err.println("任務被取消");
    } catch (InterruptedException ex) {
        System.err.println("當前線程被中斷");
    } catch (ExecutionException ex) {
        System.err.println("任務執行出錯");
    }
}

程序運行到 2 秒時候的輸出：

程序的最終輸出：

可以發現，雖然我們取消了任務，Future 的 get 方法也對我們的取消做出了響應（即拋出 CancellationException 異常），但是任務并沒有停止，而是直到任務運行完畢了，程序才結束。

查看 Future 的實現類 FutureTask 的源碼，我們來看一下調用 cancel(true) 究竟發生了什么：

原來 cancel(true) 方法的原理是向正在運行任務的線程發送中斷指令 —— 即調用運行任務的 Thread 的 interrupt() 方法。

所以 如果一個任務是可取消的，那么它應該可以對 Thread 的 interrupt() 方法做出被取消時的響應。

而 Thread 的 isInterrupted() 方法，便可以用來判斷當前 Thread 是否被中斷。任務開始運行時，運行任務的線程肯定沒有被中斷，所以 isInterruped() 方法會返回 false；而 interrupt() 方法調用之后，isInterruped() 方法會返回 true。
（由此我們也可以知道，Thread.sleep 方法是可以對中斷做出響應的）

所以我們修改 PrimerTask 的 call 方法，讓其可以對運行任務的線程被中斷時做出停止運行（跳出循環）的響應：

@Override
public Boolean call() throws Exception {
    // i < num 讓任務有足夠的運行時間
    for (long i = 2; i < num; i++) {
        if (Thread.currentThread().isInterrupted()) { // 任務被取消
            System.out.println("PrimerTask.call： 你取消我干啥？");
            return false;
        }

        if (num % i == 0) {
            return false;
        }
    }

    return true;
}

運行結果：

可以看到程序在 2 秒的時候停止了運行，任務被成功取消。

總結：如果要通過 Future 的 cancel 方法取消正在運行的任務，那么該任務必定是可以 對線程中斷做出響應 的任務。通過 Thread.currentThread().isInterrupted() 方法，我們可以判斷任務是否被取消，從而做出相應的取消任務的響應。