Startseite / Concurrency / Von unsicherer Thread-Beendigung zu kooperativem Abbruch
Concurrency Experte

Von unsicherer Thread-Beendigung zu kooperativem Abbruch

Thread.stop() und Ad-hoc-Flags durch unterbrechungsbewusste Aufgabenabbrüche ersetzen.

Concurrency Async Programming
Code-Vergleich
✕ 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);
Problem mit diesem Code entdeckt? Sag uns Bescheid.
Warum der moderne Weg gewinnt
🛡

Bewahrt Invarianten

Aufgaben stoppen nur an Codepfaden, die für den Abbruch ausgelegt sind.

🧩

Einheitliche Steuerung

Future stellt Ausführung, Abschluss und Abbruch gemeinsam dar.

🔗

Komponierbar

Unterbrechung funktioniert mit Blocking-Queues, Locks, Executors und virtuellen Threads.

Alter Ansatz
Thread.stop()
Moderner Ansatz
Future.cancel(true)
Seit JDK
5
Schwierigkeitsgrad
Experte
JDK-Unterstützung
Von unsicherer Thread-Beendigung zu kooperativem Abbruch
Verfügbar

Future und ExecutorService sind seit JDK 5 (Sept. 2004) verfügbar.

Wie es funktioniert

Thread.stop() kann Code beenden, während er Monitore besitzt oder gemeinsam genutzten Zustand aktualisiert, wodurch Objekte beschädigt bleiben können. Moderne Abbruchsteuerung ist kooperativ: Das Future mit Unterbrechung abbrechen, InterruptedException weiterleiten, wo möglich, den Unterbrechungsstatus wiederherstellen, wenn dies nicht möglich ist, und die Aufgabe so gestalten, dass sie sichere Abbruchpunkte erreicht.

Zugehörige Dokumentation
Future ↗ Thread.stop() deprecation ↗
Beweis
Beweisquelle ansehen ↗
Verwandte Muster
Concurrency Einsteiger

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
Hover für Modernes ➜
JDK 19+ →
Concurrency Experte

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());
}
Hover für Modernes ➜
JDK 25+ →
Concurrency Einsteiger

Virtual threads

Java 8
Thread thread = new Thread(() -> {
    System.out.println("hello");
});
thread.start();
thread.join();
Java 21+
Thread.startVirtualThread(() -> {
    IO.println("hello");
}).join();
Hover für Modernes ➜
JDK 21+ →