Home / Concurrency / Dalla terminazione insicura dei thread alla cancellazione cooperativa
Concurrency Avanzato

Dalla terminazione insicura dei thread alla cancellazione cooperativa

Sostituisci Thread.stop() e i flag condivisi improvvisati con una cancellazione dei task consapevole delle interruzioni.

Concurrency Async Programming
Confronto Codice
✕ 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);
Vedi un problema con questo codice? Faccelo sapere.
Perché vince l'approccio moderno
🛡

Preserva gli invarianti

I task si fermano solo nei percorsi di codice progettati per la cancellazione.

🧩

Controllo standard

Future rappresenta insieme esecuzione, completamento e cancellazione.

🔗

Componibile

L'interruzione funziona con code bloccanti, lock, executor e thread virtuali.

Approccio Vecchio
Thread.stop()
Approccio Moderno
Future.cancel(true)
Dal JDK
5
Difficoltà
Avanzato
Supporto JDK
Dalla terminazione insicura dei thread alla cancellazione cooperativa
Disponibile

Future ed ExecutorService sono disponibili da JDK 5 (sett. 2004).

Come funziona

Thread.stop() può terminare il codice mentre possiede monitor o sta aggiornando uno stato condiviso, lasciando oggetti danneggiati. La cancellazione moderna è cooperativa. Cancella il Future con interruzione, propaga InterruptedException dove possibile, ripristina lo stato di interruzione quando non può essere propagato, e progetta il task per raggiungere punti di cancellazione sicuri.

Documentazione Correlata
Future ↗ Thread.stop() deprecation ↗
Prova
Vedi sorgente di prova ↗
Pattern correlati
Concurrency Principiante

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
Passa il mouse per vedere il moderno ➜
JDK 19+ →
Concurrency Avanzato

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());
}
Passa il mouse per vedere il moderno ➜
JDK 25+ →
Concurrency Principiante

Virtual threads

Java 8
Thread thread = new Thread(() -> {
    System.out.println("hello");
});
thread.start();
thread.join();
Java 21+
Thread.startVirtualThread(() -> {
    IO.println("hello");
}).join();
Passa il mouse per vedere il moderno ➜
JDK 21+ →