Accueil / Concurrency / De l'arrêt non sécurisé des threads à l'annulation coopérative
Concurrency Avancé

De l'arrêt non sécurisé des threads à l'annulation coopérative

Remplacez Thread.stop() et les indicateurs partagés ad hoc par une annulation de tâche consciente des interruptions.

Concurrency Async Programming
Comparaison de Code
✕ Forced thread termination 
Thread worker = new Thread(this::runTask);
worker.start();

// May stop the thread while shared state is inconsistent.
worker.stop();
✓ Future cancellation 
Future<?> worker = executor.submit(this::runTask);

// Requests interruption; the task must cooperate.
worker.cancel(true);
Un problème avec ce code ? Dites-le nous.
Pourquoi la méthode moderne gagne
🛡

Préserve les invariants

Les tâches ne s'arrêtent qu'aux points de code conçus pour l'annulation.

🧩

Contrôle standard

Future représente ensemble l'exécution, l'achèvement et l'annulation.

🔗

Composable

L'interruption fonctionne avec les files bloquantes, les verrous, les executors et les threads virtuels.

Ancienne Approche
Thread.stop()
Approche Moderne
Future.cancel(true)
Depuis JDK
5
Difficulté
Avancé
Support JDK
De l'arrêt non sécurisé des threads à l'annulation coopérative
Disponible

Future et ExecutorService sont disponibles depuis JDK 5 (sept. 2004).

Comment ça fonctionne

Thread.stop() peut arrêter le code alors qu'il détient des moniteurs ou met à jour un état partagé, laissant des objets endommagés. L'annulation moderne est coopérative. Annulez le Future avec interruption, propagez InterruptedException lorsque possible, restaurez le statut d'interruption lorsque cela n'est pas possible, et concevez la tâche pour atteindre des points d'annulation sûrs.

Documentation Associée
Future ↗ Thread.stop() deprecation ↗
Preuve
Voir la preuve source ↗
Patterns associés
Concurrency Débutant

ExecutorService auto-close

Java 8
ExecutorService exec =
    Executors.newCachedThreadPool();
try {
    exec.submit(task);
} finally {
    exec.shutdown();
    exec.awaitTermination(
        1, TimeUnit.MINUTES);
}
Java 19+
try (var exec =
        Executors.newCachedThreadPool()) {
    exec.submit(task);
}
// auto shutdown + await on close
Survolez pour voir le moderne ➜
JDK 19+ →
Concurrency Avancé

Structured concurrency

Java 8
ExecutorService exec =
    Executors.newFixedThreadPool(2);
Future<User> u = exec.submit(this::fetchUser);
Future<Order> o = exec.submit(this::fetchOrder);
try {
    return combine(u.get(), o.get());
} finally { exec.shutdown(); }
Java 25 (Preview)
try (var scope = new StructuredTaskScope
        .ShutdownOnFailure()) {
    var u = scope.fork(this::fetchUser);
    var o = scope.fork(this::fetchOrder);
    scope.join().throwIfFailed();
    return combine(u.get(), o.get());
}
Survolez pour voir le moderne ➜
JDK 25+ →
Concurrency Débutant

Virtual threads

Java 8
Thread thread = new Thread(() -> {
    System.out.println("hello");
});
thread.start();
thread.join();
Java 21+
Thread.startVirtualThread(() -> {
    IO.println("hello");
}).join();
Survolez pour voir le moderne ➜
JDK 21+ →