How to handle interruption and cancellation in Java concurrent programming?

In Java concurrent programming, interruption and cancellation are methods used to stop tasks. Interruption is to stop the thread running immediately, which is achieved by calling Thread.interrupt(); cancellation is a collaborative process, which requires the task to explicitly check the cancellation status and respond, and is achieved by creating a cancelable task.

How to handle interruption and cancellation in Java concurrent programming

In concurrent programming, sometimes it is necessary to interrupt or cancel a task while it is in progress. Java provides two methods to handle these situations: interrupt and cancel.

Interruption

Interruption is a mechanism that allows a thread to stop executing the current task. This is typically used when a task needs to be stopped immediately, such as when the user cancels the operation or encounters an error. Threads can be interrupted by calling the Thread.interrupt() method.

// 中断线程
Thread thread = new Thread(() -> {
    // 线程执行的任务
    while (!Thread.currentThread().isInterrupted()) {
        // 运行任务
    }
});
thread.start();

// 在某些条件下中断线程
if (condition) {
    thread.interrupt();
}

The interrupted thread will throw InterruptedException exception. The thread can catch this exception and handle it accordingly, such as stopping the task or cleaning up the resource.

Cancellation

Cancellation is another way to stop a thread from executing the current task. Unlike interrupts, cancellation is a collaborative process that requires threads to explicitly check their cancellation status and react. Cancellation is achieved by creating a cancelable task that implements the java.util.concurrent.Future interface.

// 创建可取消任务
ExecutorService executorService = Executors.newFixedThreadPool(1);
Future<?> task = executorService.submit(() -> {
    // 线程执行的任务
    while (!task.isCancelled()) {
        // 运行任务
    }
});

// 在某些条件下取消任务
if (condition) {
    task.cancel(true);
}

When the task is canceled, the Future.isCancelled() method will return true. Threads can periodically check this status and stop tasks as needed.

The above is the detailed content of How to handle interruption and cancellation in Java concurrent programming?. For more information, please follow other related articles on the PHP Chinese website!