Home > Kursübersicht > Skalierbare Java-Systeme

Skalierbare Java-Systeme mit Virtuellen Threads & Structured Concurrency

Java Schulung mit Sven Woltmann
einmalig 1999(inkl. MwSt.: 2.378,81 €)
3 Tage oder 6x halbtags
Git-Repository und Slides
Level Experte
20. Mai  Online 20. Mai  Berlin 20. Mai  München 20. Mai  Wien 10. Jun  Wien 10. Jun  München 10. Jun  Online 10. Jun  Berlin 17. Jun  Online 17. Jun  Berlin 17. Jun  München 17. Jun  Wien

🚀 Project Loom Training

Nebenläufigkeit gehört zu den anspruchsvollsten Disziplinen der Softwareentwicklung. Thread-Pools, Futures, Callback-Ketten und komplexe Synchronisation führen häufig zu schwer wartbarem Code und subtilen Bugs – und asynchrone Ansätze wie CompletableFuture oder reaktive Frameworks verlagern das Problem mehr als sie es lösen.

Mit Project Loom hat sich das Nebenläufigkeitsmodell von Java grundlegend verändert. Virtuelle Threads entkoppeln Nebenläufigkeit von Plattform-Threads, Structured Concurrency bringt klare Struktur in parallele Abläufe, und Scoped Values ermöglichen saubere, threadsichere Kontextweitergabe - ohne den Overhead klassischer Ansätze

🧱 Virtuelle Threads Schulung

In diesem Training lernen Sie, wie Virtual Threads funktionieren, wann sie Plattform-Threads und asynchrone Modelle sinnvoll ersetzen – und wann nicht. Sie verstehen die Mechanismen hinter Mounting, Unmounting und Pinning, arbeiten mit StructuredTaskScope und dessen Join-Strategien, und setzen Scoped Values als moderne Alternative zu ThreadLocal ein. Darüber hinaus lernen Sie, welche architektonischen Konsequenzen das neue Modell hat und wie Threadsicherheit auch mit Virtual Threads gewährleistet wird.

Der Kurs ist durchgehend hands-on aufgebaut: Sie erleben direkt, wie viele klassische Plattform-Threads und wie viele Virtual Threads sich gleichzeitig betreiben lassen – und was das für die Skalierung bedeutet. Sie implementieren Structured Concurrency mit fertigen und eigenen Join-Strategien, und vergleichen, wie einfach sich virtueller Thread-Code gegenüber asynchronen Ansätzen debuggen lässt.

👥 Zielgruppe des Trainings

Dieses Training ist ideal für Java-Entwickler, Softwarearchitekten und Java-Teams, die skalierbare Backend-Systeme entwickeln oder bestehende Concurrency-Architekturen modernisieren möchten. Solide Java-Grundkenntnisse werden vorausgesetzt; Erfahrungen mit asynchronen Ansätzen und reaktiven Frameworks sind nicht erforderlich.

🏆 Exklusiv nur bei ppedv

Java Training mit Sven Woltmann

Sven Woltmann arbeitet seit über 30 Jahren mit Java – als Entwickler, Architekt, Trainer, Autor und Speaker. Mit HappyCoders.eu betreibt er einen der meistgelesenen Java-Blogs im deutschsprachigen Raum. Als Konferenz- und JUG-Speaker ist er bekannt dafür, auch anspruchsvolle technische Konzepte klar und praxisnah zu vermitteln. In seinen Trainings verbindet er tiefes technisches Verständnis mit langjähriger Projekterfahrung – mit dem Anspruch, dass das Gelernte sofort in der Projektpraxis angewendet werden kann. Exklusiv nur bei ppedv.

❓ FAQ zum Kurs

Das Training basiert auf Java 25 und verwendet durchgehend die aktuellsten APIs. Gegenüber Java 21, der ersten LTS-Version mit Virtual Threads, hat sich einiges geändert – etwa das Pinning-Verhalten in synchronized-Blöcken und die Joiner-API für Structured Concurrency. Das Training berücksichtigt diese Änderungen und vermittelt den aktuellen Stand.

Nein. Reaktive Frameworks werden im Training kurz gezeigt – aber bewusst nur so weit, dass die Komplexität sichtbar wird, die Virtual Threads und Structured Concurrency vermeiden helfen. Eigene Erfahrung damit ist kein Nachteil, aber auch keine Voraussetzung.

Jeder der zwölf Trainingsblöcke enthält ca. 30 Minuten praktische Übungen – das sind insgesamt rund 6 Stunden Hands-on-Arbeit über drei Tage. Die Übungen sind an realistischen Szenarien orientiert und bauen aufeinander auf, sodass am Ende ein vollständiges Bild entsteht.

Für Teams auf Java 17 lohnt es sich, wenn ein Upgrade geplant ist. Virtuelle Threads sind ab Java 21 einsetzbar – wer dort bereits steht, kann direkt loslegen. Das Training zeigt außerdem, was bis Java 25 hinzugekommen ist: von der Behebung des Pinning-Problems in synchronized-Blöcken über die Finalisierung der Scoped Values bis hin zur neuen Joiner-API für Structured Concurrency.

Structured Concurrency befindet sich in Java 25 noch im Preview-Status und kann sich in Details noch ändern. Das Training zeigt den aktuellen Stand und erklärt, was Preview-Status in der Praxis bedeutet. Virtual Threads und Scoped Values hingegen sind bereits finalisiert und uneingeschränkt produktionsreif

📋 Agenda Java Concurrency Training

  • Das Nebenläufigkeitsproblem in Java
    • Threads, Prozesse und Plattform-Threads im Überblick
    • Das klassische Thread-per-Request-Modell und seine Grenzen
    • Thread Pools und ExecutorServices: Funktionsweise und Schwächen
    • Ressourcenverbrauch: Speicher, Scheduling-Overhead, Kontextwechsel
  • Asynchroner Code: Die vermeintliche Lösung
    • CompletableFuture: Konzept, Komposition und Grenzen
    • Reaktive Frameworks (Project Reactor, RxJava): Grundprinzip im Überblick
    • Warum asynchroner Code schwer zu schreiben und lesen ist
    • Debugging, Observability und Wartbarkeit: Der eigentliche Preis
  • Virtual Threads: Das Konzept
    • Project Loom: Motivation und Designziele
    • Virtuelle Threads vs. Plattform-Threads: Die wesentlichen Unterschiede
    • M:N-Modell: Carrier Threads und der Fork-Join-Scheduler
    • Mounting und Unmounting: Was beim Blocking passiert
    • Pinning: synchronized (vor Java 24), JNI und die FFM API
  • Virtual Threads: Anwendung und Grenzen
    • Virtuale Threads erstellen: Thread.ofVirtual() und newVirtualThreadPerTaskExecutor()
    • Integration in Spring Boot und Jakarta EE
    • I/O-Bound vs. CPU-Bound: Wann lohnen sich Virtuelle Threads?
    • Observability: JFR, Thread Dumps und Stacktraces
  • Unstrukturierte Nebenläufigkeit: Das nächste Problem
    • Parallele Tasks mit ExecutorService und CompletableFuture: Chancen und Tücken
    • Thread Leaks und Zombie-Tasks bei unkontrollierten parallelen Abläufen
    • Fehlerbehandlung und Abbruch: Warum es so schwer ist
    • Structured vs. unstructured: Der Vergleich mit goto in der Programmierung
  • Structured Concurrency: Grundlagen
    • StructuredTaskScope öffnen: statische open()-Factory-Methoden
    • fork() und join(): Das Grundmuster für parallele Tasks
    • Joiner statt Subklassen: das neue Erweiterungsmodell
    • Built-in Joiner: allSuccessfulOrThrow(), anySuccessfulResultOrThrow() u. a.
    • Automatische Cancellation Propagation und Fehlerbehandlung
  • Structured Concurrency: Vertiefung
    • Verschachtelung von Scopes: Baumstruktur paralleler Aufgaben
    • Custom Joiner: Eigene Completion Policies implementieren
    • Timeout und Deadline auf Scope-Ebene konfigurieren
    • Vergleich mit CompletableFuture, ExecutorService und reaktiven Frameworks
  • Scoped Values
    • Kontextdaten weitergeben: Das Problem und klassische Lösungen
    • ThreadLocal: Funktionsweise, Memory Leaks und Vererbungsprobleme
    • ScopedValue: Immutabilität, Scope-Binding und automatisches Cleanup
    • API: ScopedValue.where(...).run(...) und .call(...)
    • Zusammenspiel mit StructuredTaskScope: korrekte Propagation in Kind-Tasks
  • Threadsicherheit: Was Loom nicht löst
    • Virtuelle Threads lösen kein Shared-Mutable-State-Problem
    • Atomicity und Visibility: Die zwei Grundprobleme im Java Memory Model
    • Race Conditions und Data Races: Auch mit Virtual Threads möglich
    • Synchronisationsmittel: synchronized, Locks, Atomics – aktuelle Bewertung
    • Immutability als primäres Designprinzip gegen Threadsicherheitsprobleme
  • Performance und Skalierung
    • Benchmark-Design für Nebenläufigkeit: Typische Fallstricke
    • Virtual Threads vs. Thread Pools bei I/O-Bound Workloads
    • Virtual Threads vs. async: vergleichbarer Durchsatz, einfacherer Code
    • CPU-Bound Workloads: Warum ForkJoinPool die bessere Wahl bleibt
  • Migration bestehender Systeme
    • Evolutionäre Migrationsstrategie: Wo anfangen, was priorisieren?
    • Quick Win: Executors.newVirtualThreadPerTaskExecutor() als erster Schritt
    • Pinning durch nativen Code erkennen und isolieren
    • ThreadLocal-Audit: Was auf ScopedValue migrierbar ist
    • Framework-Kompatibilität: Spring Boot, Hibernate, JDBC und Co.
  • Architektur, Best Practices und Ausblick
    • Das neue Nebenläufigkeitsmodell: Zusammenfassung und Gesamtbild
    • Entscheidungsbaum: Wann welches Concurrency-Modell?
    • Architektonische Implikationen: z. B. JDBC statt R2DBC wieder sinnvoll
    • Reactive nur noch für spezifische Event-driven-Architekturen
    • Ausblick: Weitere Entwicklungen in Project Loom und der JVM

Schulungszentren

Support Chat