Verteilte Systeme

Direkt ausführbar mit java CircuitBreaker.java

// Circuit Breaker
// Schützt vor wiederholten Aufrufen eines ausgefallenen Dienstes: Nach zu vielen Fehlern wird
// eine Zeit lang gar nicht mehr aufgerufen, sondern sofort ein Ersatzergebnis geliefert.
// Start: java CircuitBreaker.java

import java.util.function.Supplier;

public class CircuitBreaker {

    enum Zustand { GESCHLOSSEN, OFFEN, HALB_OFFEN }

    static final class Sicherung {
        private final int fehlerGrenze;
        private final long wartezeitMs;
        private Zustand zustand = Zustand.GESCHLOSSEN;
        private int fehlerInFolge = 0;
        private long geoeffnetUm;

        Sicherung(int fehlerGrenze, long wartezeitMs) { this.fehlerGrenze = fehlerGrenze; this.wartezeitMs = wartezeitMs; }

        <T> T rufe(Supplier<T> dienst, Supplier<T> ersatz, long jetztMs) {
            if (zustand == Zustand.OFFEN) {
                if (jetztMs - geoeffnetUm < wartezeitMs) return ersatz.get();     // gar nicht erst versuchen
                zustand = Zustand.HALB_OFFEN;                                     // Probeaufruf erlauben
            }
            try {
                T ergebnis = dienst.get();
                fehlerInFolge = 0;
                zustand = Zustand.GESCHLOSSEN;
                return ergebnis;
            } catch (RuntimeException e) {
                fehlerInFolge++;
                if (zustand == Zustand.HALB_OFFEN || fehlerInFolge >= fehlerGrenze) {
                    zustand = Zustand.OFFEN;
                    geoeffnetUm = jetztMs;
                }
                return ersatz.get();
            }
        }
        Zustand zustand() { return zustand; }
    }

    // --- Ein externer Dienst, der zeitweise ausfällt ---
    static boolean dienstAusgefallen = false;
    static int echteAufrufe = 0;
    static String empfehlungen() {
        echteAufrufe++;
        if (dienstAusgefallen) throw new IllegalStateException("Timeout nach 5 s");
        return "3 Empfehlungen";
    }

    public static void main(String[] args) {
        Sicherung sicherung = new Sicherung(3, 10_000);           // 3 Fehler -> 10 Sekunden offen
        long[] zeitpunkte = { 0, 1_000, 2_000, 3_000, 4_000, 5_000, 6_000, 8_000, 14_000, 15_000, 26_000, 27_000 };

        System.out.printf("%-7s %-12s %-26s %s%n", "Zeit", "Dienst", "Antwort", "Sicherung danach");
        for (long t : zeitpunkte) {
            if (t == 2_000) dienstAusgefallen = true;             // Dienst fällt aus
            if (t >= 20_000) dienstAusgefallen = false;               // und ist ab Sekunde 20 wieder da
            int vorher = echteAufrufe;
            String antwort = sicherung.rufe(CircuitBreaker::empfehlungen, () -> "Bestseller (Ersatz)", t);
            System.out.printf("%5.0f s  %-12s %-26s %s%n", t / 1000.0,
                    echteAufrufe > vorher ? "aufgerufen" : "übersprungen", antwort, sicherung.zustand());
        }
        System.out.println("\nEchte Aufrufe des Dienstes: " + echteAufrufe + " von " + zeitpunkte.length);
    }
}

Ausgabe

Zeit    Dienst       Antwort                    Sicherung danach
    0 s  aufgerufen   3 Empfehlungen             GESCHLOSSEN
    1 s  aufgerufen   3 Empfehlungen             GESCHLOSSEN
    2 s  aufgerufen   Bestseller (Ersatz)        GESCHLOSSEN
    3 s  aufgerufen   Bestseller (Ersatz)        GESCHLOSSEN
    4 s  aufgerufen   Bestseller (Ersatz)        OFFEN
    5 s  übersprungen Bestseller (Ersatz)        OFFEN
    6 s  übersprungen Bestseller (Ersatz)        OFFEN
    8 s  übersprungen Bestseller (Ersatz)        OFFEN
   14 s  aufgerufen   Bestseller (Ersatz)        OFFEN
   15 s  übersprungen Bestseller (Ersatz)        OFFEN
   26 s  aufgerufen   3 Empfehlungen             GESCHLOSSEN
   27 s  aufgerufen   3 Empfehlungen             GESCHLOSSEN

Echte Aufrufe des Dienstes: 8 von 12

Direkt ausführbar mit java RetryBackoff.java

// Retry mit Backoff
// Fehlgeschlagene Aufrufe werden wiederholt, mit wachsendem Abstand zwischen den Versuchen.
// Start: java RetryBackoff.java

import java.util.Random;
import java.util.function.Supplier;

public class RetryBackoff {

    // --- Wiederholung mit exponentiellem Backoff und Zufallsanteil (Jitter) ---
    static <T> T mitWiederholung(Supplier<T> aufruf, int maxVersuche, long startMs, Random zufall) {
        long warte = startMs;
        for (int versuch = 1; ; versuch++) {
            try {
                T ergebnis = aufruf.get();
                System.out.println("  Versuch " + versuch + ": erfolgreich");
                return ergebnis;
            } catch (VoruebergehenderFehler e) {
                if (versuch == maxVersuche) {
                    System.out.println("  Versuch " + versuch + ": " + e.getMessage() + " -> aufgeben");
                    throw e;
                }
                long jitter = (long) (warte * 0.2 * zufall.nextDouble());        // bis zu 20 % zufällig dazu
                System.out.printf("  Versuch %d: %s -> warte %d ms%n", versuch, e.getMessage(), warte + jitter);
                // Thread.sleep(warte + jitter);   // im echten Code; hier weggelassen, damit das Beispiel sofort läuft
                warte = Math.min(warte * 2, 8_000);                               // verdoppeln, aber höchstens 8 s
            }
        }
    }

    static class VoruebergehenderFehler extends RuntimeException {
        VoruebergehenderFehler(String m) { super(m); }
    }

    // --- Ein Zahlungsdienst, der die ersten n Aufrufe ablehnt ---
    static Supplier<String> dienstMitFehlern(int fehlschlaege) {
        int[] zaehler = { 0 };
        return () -> {
            if (++zaehler[0] <= fehlschlaege) throw new VoruebergehenderFehler("503 Service Unavailable");
            return "Zahlung bestätigt";
        };
    }

    public static void main(String[] args) {
        Random zufall = new Random(42);                                         // fester Startwert: gleiche Ausgabe

        System.out.println("Dienst ist kurz überlastet (3 Fehlschläge):");
        System.out.println("  Ergebnis: " + mitWiederholung(dienstMitFehlern(3), 5, 500, zufall));

        System.out.println("\nDienst bleibt ausgefallen (10 Fehlschläge):");
        try {
            mitWiederholung(dienstMitFehlern(10), 5, 500, zufall);
        } catch (VoruebergehenderFehler e) {
            System.out.println("  Ergebnis: Fehler an den Aufrufer weitergeben");
        }
    }
}

Ausgabe

Dienst ist kurz überlastet (3 Fehlschläge):
  Versuch 1: 503 Service Unavailable -> warte 572 ms
  Versuch 2: 503 Service Unavailable -> warte 1136 ms
  Versuch 3: 503 Service Unavailable -> warte 2123 ms
  Versuch 4: erfolgreich
  Ergebnis: Zahlung bestätigt

Dienst bleibt ausgefallen (10 Fehlschläge):
  Versuch 1: 503 Service Unavailable -> warte 527 ms
  Versuch 2: 503 Service Unavailable -> warte 1133 ms
  Versuch 3: 503 Service Unavailable -> warte 2361 ms
  Versuch 4: 503 Service Unavailable -> warte 4295 ms
  Versuch 5: 503 Service Unavailable -> aufgeben
  Ergebnis: Fehler an den Aufrufer weitergeben

Direkt ausführbar mit java Bulkhead.java

// Bulkhead (Schott)
// Ressourcen werden in getrennte Abteilungen aufgeteilt, damit ein überlasteter Teil nicht alles mitreißt.
// Start: java Bulkhead.java

import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;

public class Bulkhead {

    // --- Ein Schott: höchstens n gleichzeitige Aufrufe, der Rest wird sofort abgewiesen ---
    static final class Schott {
        final String name;
        private final Semaphore plaetze;
        final AtomicInteger angenommen = new AtomicInteger(), abgewiesen = new AtomicInteger();

        Schott(String name, int max) { this.name = name; this.plaetze = new Semaphore(max); }

        void rufe(Runnable aufruf) {
            if (!plaetze.tryAcquire()) {               // kein Platz frei: nicht warten, sofort ablehnen
                abgewiesen.incrementAndGet();
                return;
            }
            try {
                angenommen.incrementAndGet();
                aufruf.run();
            } finally {
                plaetze.release();
            }
        }
        public String toString() { return String.format("%-14s angenommen %2d, abgewiesen %2d", name, angenommen.get(), abgewiesen.get()); }
    }

    static void warte(long ms) { try { Thread.sleep(ms); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }

    public static void main(String[] args) {
        Schott empfehlungen = new Schott("Empfehlungen", 3);   // langsamer, unwichtiger Dienst: wenige Plätze
        Schott zahlung = new Schott("Zahlung", 10);            // wichtiger Dienst: eigene Plätze

        try (var ex = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 20; i++) {
                ex.submit(() -> empfehlungen.rufe(() -> warte(500)));   // Empfehlungsdienst hängt
            }
            warte(50);
            for (int i = 0; i < 10; i++) {
                ex.submit(() -> zahlung.rufe(() -> warte(20)));         // Zahlungen laufen normal
            }
        }
        System.out.println("20 Anfragen an den hängenden Empfehlungsdienst, 10 an den Zahlungsdienst:");
        System.out.println("  " + empfehlungen);
        System.out.println("  " + zahlung);
        System.out.println("Der hängende Dienst belegt höchstens 3 Plätze. Zahlungen sind nicht betroffen.");
    }
}

Ausgabe

20 Anfragen an den hängenden Empfehlungsdienst, 10 an den Zahlungsdienst:
  Empfehlungen   angenommen  3, abgewiesen 17
  Zahlung        angenommen 10, abgewiesen  0
Der hängende Dienst belegt höchstens 3 Plätze. Zahlungen sind nicht betroffen.

Direkt ausführbar mit java Saga.java

// Saga
// Eine verteilte Transaktion als Folge lokaler Schritte. Schlägt ein Schritt fehl,
// werden die bereits erledigten durch Ausgleichsaktionen rückgängig gemacht.
// Start: java Saga.java

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.List;

public class Saga {

    // --- Ein Schritt: Aktion + Ausgleichsaktion ---
    record Schritt(String name, Runnable aktion, Runnable ausgleich) {}

    // --- Orchestrierte Saga: führt Schritte aus, gleicht bei Fehler rückwärts aus ---
    static boolean fuehreAus(String vorgang, List<Schritt> schritte) {
        System.out.println(vorgang + ":");
        Deque<Schritt> erledigt = new ArrayDeque<>();
        for (Schritt s : schritte) {
            try {
                s.aktion().run();
                erledigt.push(s);
                System.out.println("  ✓ " + s.name());
            } catch (RuntimeException e) {
                System.out.println("  ✗ " + s.name() + ": " + e.getMessage());
                while (!erledigt.isEmpty()) {
                    Schritt zurueck = erledigt.pop();                 // in umgekehrter Reihenfolge
                    zurueck.ausgleich().run();
                    System.out.println("  ↩ Ausgleich für: " + zurueck.name());
                }
                return false;
            }
        }
        return true;
    }

    // --- Drei Dienste mit eigener Datenbank (hier nur Zustandsvariablen) ---
    static int lagerReserviert = 0;
    static long kontoBelastet = 0;
    static int sendungen = 0;

    static List<Schritt> bestellung(int menge, long cent, boolean versandMoeglich) {
        return List.of(
                new Schritt("Ware reservieren (Lagerdienst)",
                        () -> lagerReserviert += menge, () -> lagerReserviert -= menge),
                new Schritt("Zahlung einziehen (Zahlungsdienst)",
                        () -> kontoBelastet += cent, () -> kontoBelastet -= cent),
                new Schritt("Versand beauftragen (Versanddienst)",
                        () -> { if (!versandMoeglich) throw new IllegalStateException("Adresse nicht zustellbar"); sendungen++; },
                        () -> sendungen--));
    }

    public static void main(String[] args) {
        boolean ok1 = fuehreAus("Bestellung 1", bestellung(2, 5_980, true));
        System.out.println("  -> " + (ok1 ? "abgeschlossen" : "zurückgerollt"));
        System.out.println();
        boolean ok2 = fuehreAus("Bestellung 2", bestellung(1, 3_990, false));
        System.out.println("  -> " + (ok2 ? "abgeschlossen" : "zurückgerollt"));

        System.out.printf(java.util.Locale.GERMANY, "%nEndstand: reserviert %d Stück, belastet %.2f €, Sendungen %d  (nur Bestellung 1)%n",
                lagerReserviert, kontoBelastet / 100.0, sendungen);
    }
}

Ausgabe

Bestellung 1:
  ✓ Ware reservieren (Lagerdienst)
  ✓ Zahlung einziehen (Zahlungsdienst)
  ✓ Versand beauftragen (Versanddienst)
  -> abgeschlossen

Bestellung 2:
  ✓ Ware reservieren (Lagerdienst)
  ✓ Zahlung einziehen (Zahlungsdienst)
  ✗ Versand beauftragen (Versanddienst): Adresse nicht zustellbar
  ↩ Ausgleich für: Zahlung einziehen (Zahlungsdienst)
  ↩ Ausgleich für: Ware reservieren (Lagerdienst)
  -> zurückgerollt

Endstand: reserviert 2 Stück, belastet 59,80 €, Sendungen 1  (nur Bestellung 1)

Direkt ausführbar mit java ApiGateway.java

// API Gateway
// Ein einziger Einstiegspunkt vor vielen Diensten: prüft, leitet weiter und fasst Antworten zusammen.
// Start: java ApiGateway.java

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Function;

public class ApiGateway {

    // --- Interne Dienste, von außen nicht direkt erreichbar ---
    static String kundenDienst(String pfad)   { return "{\"kunde\":815,\"name\":\"Sven\"}"; }
    static String bestellDienst(String pfad)  { return "{\"offeneBestellungen\":2}"; }
    static String empfehlDienst(String pfad)  { return "[\"Lampe\",\"Tasse\"]"; }

    static final class Gateway {
        private final Map<String, Function<String, String>> routen = new LinkedHashMap<>();
        private final Set<String> gueltigeTokens = Set.of("token-sven");
        private final Map<String, Integer> anfragenProToken = new LinkedHashMap<>();
        private final int limit = 3;
        private final ExecutorService ex = Executors.newVirtualThreadPerTaskExecutor();

        Gateway() {
            routen.put("/api/kunden", ApiGateway::kundenDienst);
            routen.put("/api/bestellungen", ApiGateway::bestellDienst);
            routen.put("/api/empfehlungen", ApiGateway::empfehlDienst);
        }

        String anfrage(String token, String pfad) {
            // 1. Querschnittsaufgaben an EINER Stelle: Anmeldung, Mengenbegrenzung
            if (!gueltigeTokens.contains(token)) return "401 Nicht angemeldet";
            int n = anfragenProToken.merge(token, 1, Integer::sum);
            if (n > limit) return "429 Zu viele Anfragen";

            // 2. Zusammengesetzter Endpunkt für die App-Startseite: drei Dienste parallel, eine Antwort
            if (pfad.equals("/api/startseite")) {
                var k = CompletableFuture.supplyAsync(() -> kundenDienst(pfad), ex);
                var b = CompletableFuture.supplyAsync(() -> bestellDienst(pfad), ex);
                var e = CompletableFuture.supplyAsync(() -> empfehlDienst(pfad), ex);
                return "200 {\"kunde\":" + k.join() + ",\"bestellungen\":" + b.join() + ",\"empfehlungen\":" + e.join() + "}";
            }
            // 3. Weiterleitung an den zuständigen Dienst
            return routen.entrySet().stream().filter(r -> pfad.startsWith(r.getKey())).findFirst()
                    .map(r -> "200 " + r.getValue().apply(pfad))
                    .orElse("404 Unbekannter Pfad");
        }
    }

    public static void main(String[] args) {
        Gateway gw = new Gateway();
        String[][] anfragen = {
                { "token-sven", "/api/kunden/815" },
                { "token-sven", "/api/startseite" },
                { "falsch", "/api/bestellungen" },
                { "token-sven", "/api/lager" },
                { "token-sven", "/api/bestellungen" } };
        for (String[] a : anfragen) {
            System.out.printf("%-12s %-20s -> %s%n", a[0], a[1], gw.anfrage(a[0], a[1]));
        }
        gw.ex.shutdown();
    }
}

Ausgabe

token-sven   /api/kunden/815      -> 200 {"kunde":815,"name":"Sven"}
token-sven   /api/startseite      -> 200 {"kunde":{"kunde":815,"name":"Sven"},"bestellungen":{"offeneBestellungen":2},"empfehlungen":["Lampe","Tasse"]}
falsch       /api/bestellungen    -> 401 Nicht angemeldet
token-sven   /api/lager           -> 404 Unbekannter Pfad
token-sven   /api/bestellungen    -> 429 Zu viele Anfragen

Direkt ausführbar mit java Outbox.java

// Transactional Outbox
// Ausgehende Nachrichten werden in derselben Datenbanktransaktion gespeichert wie die Fachdaten
// und erst danach von einem eigenen Prozess zuverlässig verschickt.
// Start: java Outbox.java

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Outbox {

    record Bestellung(long nr, String kunde) {}
    record OutboxEintrag(long id, String thema, String inhalt) {}

    // --- Simulierte Datenbank mit Transaktionen ---
    static final class Datenbank {
        final List<Bestellung> bestellungen = new ArrayList<>();
        final List<OutboxEintrag> outbox = new ArrayList<>();

        void inTransaktion(Runnable arbeit, boolean absturzVorCommit) {
            int b = bestellungen.size(), o = outbox.size();
            arbeit.run();
            if (absturzVorCommit) {                                         // Rollback: beides verschwindet
                bestellungen.subList(b, bestellungen.size()).clear();
                outbox.subList(o, outbox.size()).clear();
                System.out.println("  Absturz vor dem Commit: Bestellung UND Nachricht verworfen");
            } else {
                System.out.println("  COMMIT: Bestellung und Nachricht gemeinsam gespeichert");
            }
        }
    }

    // --- Broker, der zeitweise nicht erreichbar ist ---
    static boolean brokerErreichbar = false;
    static final List<String> zugestellt = new ArrayList<>();

    // --- Relay: liest die Outbox und veröffentlicht, löscht erst nach Erfolg ---
    static void relayLauf(Datenbank db) {
        Iterator<OutboxEintrag> it = db.outbox.iterator();
        while (it.hasNext()) {
            OutboxEintrag e = it.next();
            if (!brokerErreichbar) {
                System.out.println("  Relay: Broker nicht erreichbar, Eintrag " + e.id() + " bleibt in der Outbox");
                return;
            }
            zugestellt.add(e.thema() + ": " + e.inhalt());
            it.remove();
            System.out.println("  Relay: Eintrag " + e.id() + " veröffentlicht und aus der Outbox entfernt");
        }
    }

    public static void main(String[] args) {
        Datenbank db = new Datenbank();
        long[] id = { 1 };

        System.out.println("Bestellung 4711:");
        db.inTransaktion(() -> {
            db.bestellungen.add(new Bestellung(4711, "Sven"));
            db.outbox.add(new OutboxEintrag(id[0]++, "bestellungen", "BestellungAufgegeben 4711"));
        }, false);

        System.out.println("Bestellung 4712:");
        db.inTransaktion(() -> {
            db.bestellungen.add(new Bestellung(4712, "Anna"));
            db.outbox.add(new OutboxEintrag(id[0]++, "bestellungen", "BestellungAufgegeben 4712"));
        }, true);

        System.out.println("\nRelay, Broker ausgefallen:");
        relayLauf(db);
        System.out.println("Relay, Broker wieder da:");
        brokerErreichbar = true;
        relayLauf(db);

        System.out.println("\nGespeicherte Bestellungen: " + db.bestellungen.stream().map(Bestellung::nr).toList());
        System.out.println("Zugestellte Nachrichten:   " + zugestellt);
        System.out.println("Beides passt zusammen: keine Bestellung ohne Nachricht, keine Nachricht ohne Bestellung.");
    }
}

Ausgabe

Bestellung 4711:
  COMMIT: Bestellung und Nachricht gemeinsam gespeichert
Bestellung 4712:
  Absturz vor dem Commit: Bestellung UND Nachricht verworfen

Relay, Broker ausgefallen:
  Relay: Broker nicht erreichbar, Eintrag 1 bleibt in der Outbox
Relay, Broker wieder da:
  Relay: Eintrag 1 veröffentlicht und aus der Outbox entfernt

Gespeicherte Bestellungen: [4711]
Zugestellte Nachrichten:   [bestellungen: BestellungAufgegeben 4711]
Beides passt zusammen: keine Bestellung ohne Nachricht, keine Nachricht ohne Bestellung.

Direkt ausführbar mit java StranglerFig.java

// Strangler Fig
// Ein Altsystem wird schrittweise ersetzt: Eine Weiche leitet Funktion für Funktion auf das neue System um.
// Start: java StranglerFig.java

import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

public class StranglerFig {

    interface Anwendung { String bearbeite(String pfad); }

    static final class Altsystem implements Anwendung {
        public String bearbeite(String pfad) { return "ALT  " + pfad; }
    }
    static final class NeuesSystem implements Anwendung {
        public String bearbeite(String pfad) { return "NEU  " + pfad; }
    }

    // --- Die Weiche (Fassade): entscheidet pro Funktion, wer zuständig ist ---
    static final class Weiche {
        private final Anwendung alt = new Altsystem(), neu = new NeuesSystem();
        private final Set<String> migriert = new LinkedHashSet<>();

        void migriere(String bereich) { migriert.add(bereich); }
        void zurueck(String bereich)  { migriert.remove(bereich); }        // falls im neuen System etwas schiefgeht

        String anfrage(String pfad) {
            String bereich = pfad.split("/")[1];
            return (migriert.contains(bereich) ? neu : alt).bearbeite(pfad);
        }
    }

    public static void main(String[] args) {
        Weiche weiche = new Weiche();
        List<String> anfragen = List.of("/katalog/lampe", "/warenkorb/815", "/bestellung/4711", "/rechnung/2026-10");

        String[][] phasen = {
                { "Phase 0: alles im Altsystem" },
                { "Phase 1: Katalog umgezogen", "katalog" },
                { "Phase 2: Warenkorb umgezogen", "warenkorb" },
                { "Phase 3: Bestellung und Rechnung umgezogen", "bestellung", "rechnung" } };

        for (String[] phase : phasen) {
            for (int i = 1; i < phase.length; i++) weiche.migriere(phase[i]);
            System.out.println(phase[0]);
            anfragen.forEach(a -> System.out.println("  " + weiche.anfrage(a)));
        }
        System.out.println("\nDas Altsystem bekommt keine Anfragen mehr und kann abgeschaltet werden.");
    }
}

Ausgabe

Phase 0: alles im Altsystem
  ALT  /katalog/lampe
  ALT  /warenkorb/815
  ALT  /bestellung/4711
  ALT  /rechnung/2026-10
Phase 1: Katalog umgezogen
  NEU  /katalog/lampe
  ALT  /warenkorb/815
  ALT  /bestellung/4711
  ALT  /rechnung/2026-10
Phase 2: Warenkorb umgezogen
  NEU  /katalog/lampe
  NEU  /warenkorb/815
  ALT  /bestellung/4711
  ALT  /rechnung/2026-10
Phase 3: Bestellung und Rechnung umgezogen
  NEU  /katalog/lampe
  NEU  /warenkorb/815
  NEU  /bestellung/4711
  NEU  /rechnung/2026-10

Das Altsystem bekommt keine Anfragen mehr und kann abgeschaltet werden.