Java Academy · leksjon

Feilhåndtering og kansellering

Viderefør feil på en ryddig måte

Leksjon 4 av 413 trinn

Feilhåndtering og kansellering er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

Feil i et oppgavetre

Når deloppgaver kjører samtidig, kan feil oppstå i hvilken som helst gren. Strukturert samtidighet gir Dem en disiplinert måte å videreformidle disse feilene til den overordnede oppgaven.

Denne leksjonen dekker unntak, kansellering, avbrudd og tidsavbrudd.

Hvor unntak oppstår

En deloppgave som kaster et unntak, krasjer ikke programmet umiddelbart. Unntaket lagres i Subtask-håndtaket. Hvor det blir synlig, avhenger av policyen:

ShutdownOnFailure: ved throwIfFailed()
ShutdownOnSuccess: ved result() hvis ingen lyktes

Videreformidling med throwIfFailed

Her mislykkes en deloppgave. throwIfFailed() kaster unntaket på nytt, pakket inn i ExecutionException, og vi fanger det i main.

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());
        }
    }
}

Tilordne til et egendefinert unntak

throwIfFailed tar imot en funksjon som pakker årsaken inn i Deres egen unntakstype, slik at API-et forblir ryddig.

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());
        }
    }
}

Automatisk kansellering

Når en deloppgave mislykkes under ShutdownOnFailure, kansellerer scopet søskenoppgavene ved å avbryte trådene deres. De trenger ikke skrive kanselleringskode selv.

Dette hindrer bortkastet arbeid og oppgaver som blir hengende igjen.

Avbrudd er mekanismen

Kansellering fungerer ved å avbryte deloppgavens virtuelle tråd. Samarbeidsbasert kode bør:

La blokkerende kall kaste InterruptedException
Kontrollere Thread.currentThread().isInterrupted() med jevne mellomrom i lange løkker

Reagere på avbrudd

Denne oppgaven kontrollerer avbruddsflagget i en løkke, slik at den kan stoppe tidlig når scopet avsluttes.

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();
    }
}

Tidsfrister med joinUntil

For å begrense den totale tiden bruker De joinUntil(Instant). Hvis tidsfristen utløper før alle deloppgavene er fullført, kaster metoden TimeoutException, og scopet avslutter resten.

Strukturen til et tidsavbruddsbeskyttet eksempel

En typisk fordeling av arbeid med tidsavbruddsbeskyttelse ser slik ut. Tidsfristen gjelder for hele gruppen, ikke for hver deloppgave individuelt.

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");
        }
    }
}

Kontroller alltid på nytt etter join

Disiplinen er følgende: Etter join() eller joinUntil må De alltid kalle throwIfFailed() eller lese result() før De stoler på verdien fra en deloppgave. Hvis De hopper over dette, kan feil bli skjult.

Garantert ryddig avslutning

Uansett hvordan et scope avsluttes – normalt, på grunn av en feil eller på grunn av et tidsavbrudd – garanterer lukkingen av try-with-resources-blokken at alle deloppgavetrådene er ferdige. Det finnes verken lekkasjer eller foreldreløse oppgaver.

Rask sjekk

Husk hvordan søskendeloppgaver stoppes.

Besvar den i den interaktive leksjonen

Oppsummering

De har lært om feilhåndtering og kansellering:

Unntak blir synlige ved throwIfFailed() eller result()
Tilordne årsaker til egendefinerte unntak via throwIfFailed(mapper)
Kansellering fungerer gjennom trådavbrudd; skriv samarbeidsbaserte oppgaver
joinUntil håndhever en tidsfrist for gruppen
Lukking av scopet rydder alltid opp

Dette fullfører kurset i strukturert samtidighet.

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 104
Leksjoner: 374

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Feilhåndtering og kansellering» gratis?

Ja – hele teksten i «Feilhåndtering og kansellering» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Feilhåndtering og kansellering»?

Viderefør feil på en ryddig måte Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Feilhåndtering og kansellering»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Java Academy