java如何取消异步任务模块

Java取消异步任务模块的方法包括使用Future.cancel()、使用ExecutorService.shutdownNow()、自定义取消标志。 其中，Future.cancel() 是最常用的方法，因为它提供了一种标准化的方式来取消特定的任务。下面将详细介绍如何使用这几种方法来取消Java中的异步任务，并讨论每种方法的优缺点。

一、FUTURE.CANCEL() 方法

Future.cancel() 是Java中的一种标准方法，用于取消通过ExecutorService提交的异步任务。它有两个参数：boolean mayInterruptIfRunning，如果设置为true，它将尝试中断正在运行的任务。

1.1 使用 Future.cancel() 的基本方法

首先，需要创建一个ExecutorService，并提交一个Callable或Runnable任务。提交任务时，返回一个Future对象，通过调用该对象的cancel()方法来取消任务。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class CancelTaskExample {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Callable<String> task = () -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Task is running");
                Thread.sleep(1000);
            }
            return "Task completed";
        };
        Future<String> future = executor.submit(task);
        Thread.sleep(3000); // Simulate some delay
        boolean cancelled = future.cancel(true);
        System.out.println("Task cancelled: " + cancelled);
        executor.shutdown();
    }
}

1.2 取消任务的注意事项

mayInterruptIfRunning 参数设为true时，表示如果任务正在运行，将尝试中断。如果设为false，任务将继续运行直到完成。
任务必须定期检查中断标志，以便能够响应取消请求。
取消任务后，调用Future.get()会抛出CancellationException。

二、EXECUTORSERVICE.SHUTDOWNNOW() 方法

ExecutorService.shutdownNow() 会尝试停止所有正在执行的任务，并返回等待执行的任务列表。它会中断正在运行的任务，但是不保证立即停止。

2.1 使用 ExecutorService.shutdownNow() 的基本方法

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ShutdownNowExample {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        Runnable task1 = () -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("Task 1 is running");
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                System.out.println("Task 1 is interrupted");
            }
        };
        Runnable task2 = () -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("Task 2 is running");
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                System.out.println("Task 2 is interrupted");
            }
        };
        executor.submit(task1);
        executor.submit(task2);
        Thread.sleep(3000); // Simulate some delay
        executor.shutdownNow();
        System.out.println("Executor is shut down");
        if (!executor.awaitTermination(5, java.util.concurrent.TimeUnit.SECONDS)) {
            System.out.println("Some tasks are still running");
        }
    }
}

2.2 取消任务的注意事项

shutdownNow() 会中断所有正在运行的任务，因此任务必须处理InterruptedException。
它会返回未执行任务的列表，允许进一步处理。

三、自定义取消标志

有时，使用自定义取消标志可以提供更细粒度的控制。可以通过共享一个标志来通知任务停止。

3.1 使用自定义取消标志的基本方法

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CustomCancelFlagExample {
    private static volatile boolean cancelFlag = false;
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Runnable task = () -> {
            while (!cancelFlag) {
                System.out.println("Task is running");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.out.println("Task is interrupted");
                }
            }
            System.out.println("Task is cancelled");
        };
        executor.submit(task);
        Thread.sleep(3000); // Simulate some delay
        cancelFlag = true;
        executor.shutdown();
    }
}

3.2 取消任务的注意事项

自定义取消标志需要设置为volatile，以确保线程间的可见性。
任务需要定期检查取消标志，以便及时响应取消请求。

四、总结

在Java中取消异步任务可以通过多种方式实现，包括Future.cancel()、ExecutorService.shutdownNow() 和自定义取消标志。每种方法都有其优缺点：

Future.cancel() 提供了一种标准化的方法来取消特定任务，但需要任务定期检查中断标志。
ExecutorService.shutdownNow() 可以中断所有正在运行的任务，但不保证立即停止。
自定义取消标志提供了更细粒度的控制，但需要额外的实现和管理。

在选择取消异步任务的方法时，应根据具体场景和需求进行权衡。对于大多数情况，Future.cancel() 是首选方法，因为它简洁且易于使用。