WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Thread: starten, auf Beendigung warten und unterbrechen

Erzeuge Plattform-Threads aus Runnable-Aufgaben, starte sie einmal, lies Ergebnisse nach join() und behandle kooperative Abbrüche, ohne den Interrupt-Status zu verlieren.

Version: Java SE 21

Syntax

new Thread(task);             // task: Runnable
new Thread(task, name);       // name: String
worker.start();               // void
worker.join();                // void; throws InterruptedException
worker.join(millis);          // long; same return and checked exception
worker.join(millis, nanos);   // long, int; same return and checked exception
worker.join(duration);        // java.time.Duration; boolean; throws InterruptedException
Thread.currentThread();       // static; returns Thread
worker.getName();             // returns String
worker.interrupt();           // request interruption of worker
Thread.currentThread().interrupt(); // set the calling thread's interrupt status

In Java SE 21 erzeugen beide Konstruktoren von java.lang.Thread einen noch nicht gestarteten Plattform-Thread, keinen virtuellen Thread. Thread(Runnable) erzeugt einen Namen; Thread(Runnable,String) übernimmt den angegebenen Namen. Die statische Methode Thread.currentThread() liefert den ausführenden Thread. Die Instanzmethode getName() liefert dessen Namen, keine eindeutige Kennung.

worker.start() plant die Ausführung der Aufgabe im neuen Thread ein. Ein direkter Aufruf von worker.run() führt sie im aufrufenden Thread aus. Ein zweiter Aufruf von start() löst auch nach Beendigung eine IllegalThreadStateException aus. Aktionen vor start() sind über die happens-before-Beziehung für den gestarteten Thread sichtbar. Die Aufrufreihenfolge legt die Ausführungsreihenfolge nicht fest.

worker.join() lässt den Aufrufer auf das Ende des gestarteten Workers warten; bei einem nicht gestarteten Thread kehrt die Methode sofort zurück. Nach normaler Rückkehr von join() für einen gestarteten Thread sind dessen Schreibzugriffe für den Aufrufer sichtbar. Warte vor dem Lesen auf alle Threads, die Ergebnisse erzeugen. Das behebt weder Datenrennen zwischen ihnen noch weist es den Erfolg ihrer Aufgaben nach. join(long) und join(long,int) können nach Ablauf der Frist zurückkehren; ausschließlich Nullen bedeuten keine Frist. join(Duration) meldet, ob der Thread beendet ist, und wirft bei einem nicht gestarteten Thread IllegalThreadStateException.

worker.interrupt() signalisiert dem Worker eine Unterbrechung, stoppt ihn aber nicht zwangsweise. Wenn join() oder await() eine InterruptedException wirft, wird der Interrupt-Status des aufrufenden Threads gelöscht. Gib die Ausnahme möglichst weiter. Sonst räume auf, stelle den Status mit Thread.currentThread().interrupt() wieder her und beende den Abbruchpfad ohne Erfolgsmeldung. isInterrupted() liest den Status, ohne ihn zu löschen; das statische Thread.interrupted() liest und löscht den Status des aktuellen Threads. Verlass dich nicht darauf, dass interrupt() bei einem nicht lebenden Thread wirkt. In Java SE 21 kann ein Security Manager das Unterbrechen eines anderen Threads verbieten.

Beispiele

import java.util.concurrent.CountDownLatch;

public class ThreadMethodsDemo {
    public static void main(String[] args) throws InterruptedException {
        var gate = new CountDownLatch(1);
        var observations = new String[2];

        Thread compute = new Thread(() -> observations[0] = "sum=" + (20 + 22));
        Thread cancellable = new Thread(() -> {
            Thread self = Thread.currentThread();
            try {
                gate.await();
            } catch (InterruptedException e) {
                self.interrupt();
                observations[1] = self.getName() + ": cancelled; interrupted="
                        + self.isInterrupted();
                return;
            }
        }, "cancellable");

        compute.start();
        cancellable.start();
        cancellable.interrupt();
        compute.join();
        cancellable.join();

        System.out.println(observations[0]);
        System.out.println(observations[1]);
    }
}

Ergebnis

sum=42
cancellable: cancelled; interrupted=true

Der erste Thread speichert eine Summe, der benannte Thread einen Abbruch. Die Sperre bleibt geschlossen: `await()` reagiert auf den Interrupt vor oder während des Wartens. Nur `main` gibt nach beiden `join()`-Aufrufen etwas aus; die Zeilenreihenfolge hängt nicht vom Scheduler ab.

Zugehörige Lektionen

  • Java · Lektion 25 · Fortgeschritten · Version: 2
  • Java · Lektion 28 · Fortgeschritten · Version: 2
  • Java · Lektion 30 · Fortgeschritten · Version: 2
  • Java · Lektion 33 · Fortgeschritten · Version: 2
  • Java · Lektion 34 · Fortgeschritten · Version: 2
  • Java · Lektion 35 · Fortgeschritten · Version: 2
  • Java · Lektion 36 · Fortgeschritten · Version: 2
  • Java · Lektion 37 · Fortgeschritten · Version: 2
  • Java · Lektion 38 · Fortgeschritten · Version: 2

Quellen