Java Concurrency Training

Skalierbare Java-Systeme mit Virtuellen Threads & Structured Concurrency

Lernen Sie, wie Project Loom das Nebenläufigkeitsmodell von Java verändert: Virtual Threads, Structured Concurrency und Scoped Values machen skalierbare Backend-Systeme wieder lesbarer, beobachtbarer und wartbarer.

Virtual Threads Structured Concurrency Java 25
Antike Maschine mit Java-Kaffeetasse als Sinnbild für moderne Java-Concurrency
einmalig 1999 € (inkl. MwSt.: 2.378,81 €)
3 Tage oder 6x halbtags
Git-Repository und Slides
Level Experte
Termin wählen
10. Jun  Wien 10. Jun  Online 24. Jun  Burghausen 24. Jun  Online 08. Jul  Online 08. Jul  München 08. Jul  Online 08. Jul  Wien 10. Jul  Online 22. Jul  Online 22. Jul  Berlin 22. Jul  Berlin 22. Jul  Online 05. Aug  Online 05. Aug  München 05. Aug  Wien 05. Aug  Online 07. Aug  Online 19. Aug  Online 19. Aug  Online 19. Aug  Burghausen 19. Aug  Burghausen 02. Sep  Online 02. Sep  Burghausen

Project Loom praxisnah einsetzen

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. Asynchrone Ansätze wie CompletableFuture oder reaktive Frameworks verlagern das Problem oft 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.

Virtual Threads und Architekturentscheidungen

In diesem Training lernen Sie, wie Virtual Threads funktionieren, wann sie Plattform-Threads und asynchrone Modelle sinnvoll ersetzen und wann nicht. Sie verstehen Mounting, Unmounting und Pinning, arbeiten mit StructuredTaskScope und Join-Strategien und setzen Scoped Values als moderne Alternative zu ThreadLocal ein.

Der Kurs ist durchgehend hands-on aufgebaut. Sie vergleichen Plattform-Threads und Virtual Threads, implementieren Structured Concurrency mit fertigen und eigenen Join-Strategien und erleben, wie gut sich virtueller Thread-Code gegenüber asynchronen Ansätzen debuggen lässt.

Zielgruppe

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 oder reaktiven Frameworks sind nicht erforderlich.

Exklusiv bei ppedv

Java Trainer Sven Woltmann

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. Er vermittelt anspruchsvolle technische Konzepte klar, praxisnah und mit langjähriger Projekterfahrung.

Agenda Java Concurrency Training

Grundlagen der Nebenläufigkeit

  • 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

  • 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

  • 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
  • Virtuelle 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

Structured Concurrency

  • Unstrukturierte Nebenläufigkeit mit ExecutorService und CompletableFuture
  • Thread Leaks und Zombie-Tasks bei unkontrollierten parallelen Abläufen
  • Fehlerbehandlung, Abbruch und Cancellation Propagation
  • 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.
  • Verschachtelung von Scopes und Custom Joiner
  • Timeout und Deadline auf Scope-Ebene konfigurieren
  • Vergleich mit CompletableFuture, ExecutorService und reaktiven Frameworks

Scoped Values und Threadsicherheit

  • 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
  • Virtuelle Threads lösen kein Shared-Mutable-State-Problem
  • Atomicity, Visibility, Race Conditions und Data Races
  • Synchronisationsmittel: synchronized, Locks, Atomics - aktuelle Bewertung
  • Immutability als primäres Designprinzip

Performance, Migration und Ausblick

  • 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
  • Evolutionäre Migrationsstrategie: Wo anfangen, was priorisieren?
  • 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.
  • Entscheidungsbaum: Wann welches Concurrency-Modell?
  • JDBC statt R2DBC wieder sinnvoll einordnen
  • Reactive nur noch für spezifische Event-driven-Architekturen
  • Ausblick: Weitere Entwicklungen in Project Loom und der JVM

Ihre Vorteile

Kleingruppen und direkter Austausch mit dem Trainer
Rund 6 Stunden Hands-on-Arbeit mit realistischen Übungen
Live Git-Repository und Slides als Lernmaterial
Teilnahmezertifikat
12 Monate Trainersupport
1 Jahr Wiederholung Garantie 99€

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.

Weitere Kurse zum Thema

Schulungszentren

Support Chat