0Pricing
Java Academy · Lektion

Fehlerbehandlung und Abbruch

Fehler sauber weitergeben

Fehlerbehandlung und Abbruch ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Fehler in einem Aufgabenbaum

Wenn Teilaufgaben nebenläufig ausgeführt werden, können in jedem Zweig Fehler auftreten. Strukturierte Nebenläufigkeit bietet eine disziplinierte Möglichkeit, diese Fehler an das übergeordnete Element zu propagieren.

Diese Lektion behandelt Ausnahmen, Abbruch, Unterbrechung und Zeitüberschreitungen.

Wo Ausnahmen sichtbar werden

Eine Teilaufgabe, die eine Ausnahme auslöst, bringt Ihr Programm nicht sofort zum Absturz. Die Ausnahme wird im Subtask-Handle gespeichert. Wo sie sichtbar wird, hängt von der Richtlinie ab:

  • ShutdownOnFailure: bei throwIfFailed()
  • ShutdownOnSuccess: bei result(), wenn keine Teilaufgabe erfolgreich war

Weitergabe mit throwIfFailed

Hier schlägt eine Teilaufgabe fehl. throwIfFailed() löst die Ausnahme erneut aus, verpackt in einer ExecutionException, die wir in main abfangen.

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            scope.fork(() -> "ok");
            scope.fork(() -> { throw new RuntimeException("boom"); });
            scope.join();
            scope.throwIfFailed();
            System.out.println("never reached");
        } catch (ExecutionException e) {
            System.out.println("Caught cause: " + e.getCause().getMessage());
        }
    }
}

In eine eigene Ausnahme umwandeln

throwIfFailed akzeptiert eine Funktion, die die Ursache in Ihren eigenen Ausnahmetyp verpackt und so Ihre API übersichtlich hält.

import java.util.concurrent.StructuredTaskScope;

class DataAccessException extends Exception {
    DataAccessException(Throwable cause) { super(cause); }
}

public class Main {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            scope.fork(() -> { throw new RuntimeException("db down"); });
            scope.join();
            scope.throwIfFailed(DataAccessException::new);
        } catch (DataAccessException e) {
            System.out.println("Wrapped: " + e.getCause().getMessage());
        }
    }
}

Automatischer Abbruch

Wenn eine Teilaufgabe unter ShutdownOnFailure fehlschlägt, bricht der Scope die gleichgeordneten Teilaufgaben ab, indem er deren Threads unterbricht. Sie müssen keinen eigenen Abbruchcode schreiben.

So werden unnötige Arbeit und verwaiste Aufgaben vermieden.

Unterbrechung ist der Mechanismus

Der Abbruch funktioniert, indem der virtuelle Thread der Teilaufgabe unterbrochen wird. Kooperativer Code sollte:

  • Blockierende Aufrufe InterruptedException auslösen lassen
  • In langen Schleifen regelmäßig Thread.currentThread().isInterrupted() prüfen

Auf Unterbrechungen reagieren

Diese Aufgabe prüft in einer Schleife das Unterbrechungs-Flag, damit sie vorzeitig beendet werden kann, wenn der Scope beendet wird.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.ofVirtual().start(() -> {
            long count = 0;
            while (!Thread.currentThread().isInterrupted()) {
                count++;
                if (count == 1_000_000) break;
            }
            System.out.println("Stopped after " + count + " iterations");
        });
        t.join();
    }
}

Deadlines mit joinUntil

Um die Gesamtdauer zu begrenzen, verwenden Sie joinUntil(Instant). Wenn die Deadline abläuft, bevor alle Teilaufgaben abgeschlossen sind, wird TimeoutException ausgelöst und der Scope beendet die übrigen Teilaufgaben.

Aufbau eines typischen Timeouts

Eine typische Aufgabenverteilung mit Timeout-Schutz sieht so aus. Die Deadline gilt für die gesamte Gruppe, nicht für jede Teilaufgabe einzeln.

import java.time.*;
import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            scope.fork(() -> "fast");
            scope.joinUntil(Instant.now().plus(Duration.ofSeconds(2)));
            scope.throwIfFailed();
            System.out.println("Completed within deadline");
        } catch (TimeoutException e) {
            System.out.println("Deadline exceeded");
        } catch (ExecutionException e) {
            System.out.println("A subtask failed");
        }
    }
}

Nach join immer erneut prüfen

Die wichtige Regel lautet: Rufen Sie nach join() (oder joinUntil) immer throwIfFailed() auf oder lesen Sie result(), bevor Sie einem Wert einer Teilaufgabe vertrauen. Wenn Sie dies überspringen, können Fehler unbemerkt bleiben.

Sauberes Beenden garantiert

Unabhängig davon, wie ein Scope endet – regulär, aufgrund eines Fehlers oder wegen einer Zeitüberschreitung – garantiert das Schließen des try-with-resources-Blocks, dass jeder Thread einer Teilaufgabe beendet ist. Es gibt weder Leaks noch verwaiste Aufgaben.

Kurzer Test

Rufen Sie sich in Erinnerung, wie gleichgeordnete Teilaufgaben beendet werden.

Zusammenfassung

Sie haben Fehlerbehandlung und Abbruch kennengelernt:

  • Ausnahmen werden bei throwIfFailed() oder result() sichtbar
  • Wandeln Sie Ursachen mit throwIfFailed(mapper) in eigene Ausnahmen um
  • Der Abbruch erfolgt durch die Unterbrechung des Threads; schreiben Sie kooperative Aufgaben
  • joinUntil setzt eine Deadline für die gesamte Gruppe durch
  • Beim Schließen des Scopes werden immer alle Ressourcen bereinigt

Damit ist der Kurs zur strukturierten Nebenläufigkeit abgeschlossen.

Häufig gestellte Fragen

Ist die Lektion „Fehlerbehandlung und Abbruch“ kostenlos?

Ja — der vollständige Text von „Fehlerbehandlung und Abbruch“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Fehlerbehandlung und Abbruch“?

Fehler sauber weitergeben Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Fehlerbehandlung und Abbruch“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Das Modell der strukturierten Nebenläufigkeit
  2. StructuredTaskScope
  3. Beenden bei Fehler und Erfolg
  4. Fehlerbehandlung und Abbruch
← Zurück zu Java Academy