Início / Concurrency / Encerramento inseguro de threads para cancelamento cooperativo
Concurrency Avançado

Encerramento inseguro de threads para cancelamento cooperativo

Substitua Thread.stop() e flags compartilhadas improvisadas por cancelamento de tarefas consciente de interrupção.

Concurrency Async Programming
Comparação de Código
✕ 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);
Viu um problema com este código? Nos avise.
Por que a forma moderna ganha
🛡

Preserva invariantes

As tarefas param apenas em caminhos de código projetados para cancelamento.

🧩

Controle padrão

Future representa execução, conclusão e cancelamento em conjunto.

🔗

Composição

A interrupção funciona com filas bloqueantes, locks, executors e threads virtuais.

Abordagem Antiga
Thread.stop()
Abordagem Moderna
Future.cancel(true)
Desde o JDK
5
Dificuldade
Avançado
Suporte JDK
Encerramento inseguro de threads para cancelamento cooperativo
Disponível

Future e ExecutorService estão disponíveis desde o JDK 5 (set. 2004).

Como funciona

Thread.stop() pode encerrar o código enquanto ele detém monitores ou está atualizando estado compartilhado, deixando objetos danificados. O cancelamento moderno é cooperativo. Cancele o Future com interrupção, propague InterruptedException quando possível, restaure o status de interrupção quando não puder ser propagado, e projete a tarefa para alcançar pontos seguros de cancelamento.

Documentação Relacionada
Future ↗ Thread.stop() deprecation ↗
Prova
Ver código de prova ↗
Padrões relacionados
Concurrency Iniciante

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
Passe o mouse para ver o moderno ➜
JDK 19+ →
Concurrency Avançado

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());
}
Passe o mouse para ver o moderno ➜
JDK 25+ →
Concurrency Iniciante

Virtual threads

Java 8
Thread thread = new Thread(() -> {
    System.out.println("hello");
});
thread.start();
thread.join();
Java 21+
Thread.startVirtualThread(() -> {
    IO.println("hello");
}).join();
Passe o mouse para ver o moderno ➜
JDK 21+ →