Inicio / Concurrency / Terminación insegura de hilos a cancelación cooperativa
Concurrency Avanzado

Terminación insegura de hilos a cancelación cooperativa

Sustituye Thread.stop() y las banderas compartidas improvisadas por una cancelación de tareas consciente de la interrupción.

Concurrency Async Programming
Comparación 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);
¿Ves un problema con este código? Cuéntanos.
Por qué gana la forma moderna
🛡

Preserva invariantes

Las tareas se detienen solo en rutas de código diseñadas para la cancelación.

🧩

Control estándar

Future representa la ejecución, la finalización y la cancelación en conjunto.

🔗

Componible

La interrupción funciona con colas bloqueantes, locks, executors e hilos virtuales.

Enfoque Antiguo
Thread.stop()
Enfoque Moderno
Future.cancel(true)
Desde JDK
5
Dificultad
Avanzado
Soporte JDK
Terminación insegura de hilos a cancelación cooperativa
Disponible

Future y ExecutorService están disponibles desde JDK 5 (sept. 2004).

Cómo funciona

Thread.stop() puede terminar el código mientras posee monitores o está actualizando estado compartido, dejando los objetos dañados. La cancelación moderna es cooperativa. Cancela el Future con interrupción, propaga InterruptedException cuando sea posible, restaura el estado de interrupción cuando no se puede propagar, y diseña la tarea para que alcance puntos seguros de cancelación.

Documentación Relacionada
Future ↗ Thread.stop() deprecation ↗
Prueba
Ver código de prueba ↗
Patrones relacionados
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
Pasa el ratón para ver el moderno ➜
JDK 19+ →
Concurrency Avanzado

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());
}
Pasa el ratón para ver el 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();
Pasa el ratón para ver el moderno ➜
JDK 21+ →