Strona główna / Concurrency / Od niebezpiecznego zatrzymywania wątków do kooperatywnego anulowania
Concurrency Zaawansowany

Od niebezpiecznego zatrzymywania wątków do kooperatywnego anulowania

Zastąp Thread.stop() i doraźne współdzielone flagi anulowaniem zadań świadomym przerwań.

Concurrency Async Programming
Porównanie kodu
✕ 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);
Widzisz problem z tym kodem? Daj nam znać.
Dlaczego nowoczesne podejście wygrywa
🛡

Zachowuje niezmienniki

Zadania zatrzymują się tylko w ścieżkach kodu zaprojektowanych do anulowania.

🧩

Standardowa kontrola

Future reprezentuje wykonanie, ukończenie i anulowanie razem.

🔗

Komponowalność

Przerwanie działa z kolejkami blokującymi, blokadami, executorami i wątkami wirtualnymi.

Stare podejście
Thread.stop()
Nowoczesne podejście
Future.cancel(true)
Od JDK
5
Poziom trudności
Zaawansowany
Wsparcie JDK
Od niebezpiecznego zatrzymywania wątków do kooperatywnego anulowania
Dostępne

Future i ExecutorService są dostępne od JDK 5 (wrzesień 2004)

Jak to działa

Thread.stop() może zakończyć kod, gdy ten posiada monitory lub aktualizuje współdzielony stan, pozostawiając obiekty uszkodzone. Nowoczesne anulowanie jest kooperatywne. Anuluj Future z przerwaniem, propaguj InterruptedException tam, gdzie to możliwe, przywróć status przerwania, gdy nie można go propagować, i zaprojektuj zadanie tak, aby osiągało bezpieczne punkty anulowania.

Powiązana dokumentacja
Future ↗ Thread.stop() deprecation ↗
Dowód
Zobacz źródło dowodu ↗
Powiązane wzorce
Concurrency Początkujący

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
Najedź, aby zobaczyć nową wersję ➜
JDK 19+ →
Concurrency Zaawansowany

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());
}
Najedź, aby zobaczyć nową wersję ➜
JDK 25+ →
Concurrency Początkujący

Virtual threads

Java 8
Thread thread = new Thread(() -> {
    System.out.println("hello");
});
thread.start();
thread.join();
Java 21+
Thread.startVirtualThread(() -> {
    IO.println("hello");
}).join();
Najedź, aby zobaczyć nową wersję ➜
JDK 21+ →