Comment gérer les interruptions et les annulations dans la programmation simultanée Java ?

Dans la programmation simultanée Java, l'interruption et l'annulation sont des méthodes utilisées pour arrêter les tâches. L'interruption consiste à arrêter immédiatement l'exécution du thread, ce qui est obtenu en appelant Thread.interrupt(); l'annulation est un processus collaboratif, qui nécessite que la tâche vérifie explicitement l'état d'annulation et réponde, et est obtenue en créant une tâche annulable.

Comment gérer l'interruption et l'annulation en programmation simultanée Java

En programmation simultanée, il est parfois nécessaire d'interrompre ou d'annuler une tâche pendant qu'elle est en cours. Java propose deux méthodes pour gérer ces situations : interrompre et annuler.

Interruptions

Les interruptions sont un mécanisme qui permet à un thread d'arrêter l'exécution de la tâche en cours. Ceci est généralement utilisé lorsqu'une tâche doit être arrêtée immédiatement, par exemple lorsque l'utilisateur annule l'opération ou rencontre une erreur. Les threads peuvent être interrompus en appelant la méthode Thread.interrupt(). Thread.interrupt() 方法可以中断线程。

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

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

被中断的线程会抛出 InterruptedException 异常。线程可以捕获此异常并做出相应的处理，例如停止任务或清理资源。

取消

取消是另一种让线程停止执行当前任务的方法。与中断不同的是，取消是一个协作过程，需要线程明确检查其取消状态并做出反应。通过创建实现 java.util.concurrent.Future 接口的可取消任务，可以实现取消。

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

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

当任务被取消时，Future.isCancelled() 方法将返回 truerrreee

Les threads interrompus lanceront des exceptions InterruptedException. Le thread peut intercepter cette exception et la gérer en conséquence, par exemple en arrêtant la tâche ou en nettoyant la ressource. 🎜🎜🎜Annulation🎜🎜🎜L'annulation est une autre façon d'empêcher un thread d'exécuter la tâche en cours. Contrairement aux interruptions, l'annulation est un processus collaboratif qui nécessite que les threads vérifient explicitement leur statut d'annulation et réagissent. L'annulation est obtenue en créant une tâche annulable qui implémente l'interface java.util.concurrent.Future. 🎜rrreee🎜Lorsque la tâche est annulée, la méthode Future.isCancelled() renverra true. Les threads peuvent vérifier périodiquement cet état et arrêter les tâches si nécessaire. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!