Lektionen

Wir klären, warum der klassische ThreadLocal in der Welt virtueller Threads an Relevanz verliert und wie ihn ScopedValue ersetzt: ein Kontext, der an den Ausführungsbereich gebunden ist und nicht an den Thread. Schritt-für-Schritt-Beispiele zur Kontextübergabe (Benutzer, REQUEST_ID), verschachtelte Scopes und deren Überlagerung, Integration mit virtuellen Threads ( Executors. newVirtualThreadPerTaskExecutor()). Wir vergleichen ThreadLocal vs ScopedValue, geben Praxistipps, nennen Einschränkungen und blicken auf Structured Concurrency (Vorschau).

Structured Concurrency verwandelt ein chaotisches Sammelsurium von Threads in eine beherrschbare Aufgabenhierarchie: Sie starten Unteraufgaben in virtuellen Threads innerhalb von StructuredTaskScope, warten mit join(), behandeln Fehler zentralisiert mit throwIfFailed() und holen Ergebnisse mit resultNow()/ result(). Wir besprechen die Abschlussrichtlinien ShutdownOnFailure und ShutdownOnSuccess, vergleichen mit CompletableFuture, schauen uns Beispiele eines HTTP-Aggregators an und typische Fehler bei der Verwendung strukturierter Nebenläufigkeit.

Wie man lange und blockierende Operationen in Java korrekt abbricht: kooperatives Unterbrechen durch Thread.interrupt(), Abbruch von Aufgaben über Future.cancel() und das Verhalten von CancellationException, Timeouts und Abbruch in CompletableFuture ( orTimeout, completeOnTimeout), strukturierte Nebenläufigkeit mit StructuredTaskScope, gemeinsame Deadline (Time‑Budget) und das Weiterreichen von Timeouts nach unten durch den Stack (einschließlich Instant/ Duration und Scoped Values). Wir betrachten die Praxis mit blockierendem I/O und typische Fehler.

In dieser Vorlesung besprechen wir High-Level-Synchronisierer aus java.util.concurrent: CountDownLatch, CyclicBarrier, Phaser und Exchanger. Wir lernen, den Start und Abschluss von Aufgaben über await()/ countDown() zu koordinieren, wiederverwendbare Phasen und Barriereaktionen mit await() aufzubauen, dynamische Teilnehmer des „Orchesters“ mit register()/ arriveAndAwaitAdvance()/ arriveAndDeregister() zu steuern und paarweise Daten über exchange() auszutauschen. In der Praxis implementieren wir einen Massenstart von Workern und den „Spiel‑Tick“ und besprechen typische Fehler: die Einmaligkeit von CountDownLatch, den Umgang mit BrokenBarrierException und ein korrektes deregister(). Überall kommen wir ohne den Schmerz von wait()/ notify() aus.

Wenn ReentrantReadWriteLock und der klassische ReadWriteLock unter hoher Last ins Stocken geraten, hilft StampedLock mit optimistischem Lesen: Die Kombination aus tryOptimisticRead + validate liefert nahezu „kostenlose“ Lesezugriffe bei seltenen Schreibvorgängen. Wir beleuchten die Sperrmodi, den Umgang mit Stempeln, die Grenzen bei Reentrancy, vergleichen mit ReentrantReadWriteLock und betrachten kontentionsarme Zähler – LongAdder und LongAccumulator – sowie warum sie AtomicLong unter Konkurrenz übertreffen. Wir schließen mit Praxis: ein Cache mit Leseübergewicht und ein Mini-Benchmark.

Wir beleuchten die Regeln für Sichtbarkeit und Reihenfolge von Operationen im Java Memory Model: was die Relation happens-before bedeutet, wie und wann volatile, synchronized, finale Felder ( final) helfen und warum ohne sie „veraltete“ Daten entstehen. Wir zeigen die sichere Veröffentlichung von Objekten, korrektes double-checked locking, Low-Level-Zugriff über VarHandle, die Auswirkungen von False Sharing und die Annotation @Contended sowie praktische Hinweise zu Thread.start()/ Thread.join(), Future.get() und den Mikrobenchmarks JMH.

Praktischer Leitfaden zur parallelen Dateiverarbeitung in Java: wann Multithreading I/O wirklich beschleunigt und wann nicht, die Auswahl der Werkzeuge — Thread, Thread-Pool über ExecutorService, Asynchronität mit CompletableFuture und parallele Streams — sowie das Lesen großer Dateien in Chunks über FileChannel, sicheres Schreiben in ein gemeinsames Log und Einschränkungen von OS/FS. Wir besprechen Startmuster für Tasks, Pool-Konfigurationen, die Methoden shutdown()/ awaitTermination() und typische Fehler.

Praxisnaher Leitfaden zur Parallelisierung von Datei-Aufgaben in Java: wie man Parallelität in der Stream-API per parallel()/ parallelStream() einschaltet, wie der ForkJoinPool funktioniert und konfiguriert wird und wann man besser RecursiveTask verwendet. Wir besprechen, wo Parallelität I/O tatsächlich beschleunigt, wie man den gemeinsamen Thread-Pool verwaltet und wie man Ressourcen sicher schließt ( try-with-resources). Zum Schluss – ein schneller Blick auf den positionsbasierten Zugriff über FileChannel zum Lesen/Schreiben von Teilen großer Dateien.

Wie man das Durchlaufen großer Verzeichnisse und die Verarbeitung von Tausenden Dateien beschleunigt: Wir verwenden Files.walk() und parallele Streams über parallel(), verstehen die Rolle von ForkJoinPool.commonPool() und konfigurieren den Grad der Parallelität. Wir klären, wann man besser auf ExecutorService umsteigt, worin sich CPU-bound- und IO-bound-Aufgaben unterscheiden, schreiben ein Beispiel zum Zeilenzählen in allen ".java"-Dateien und halten Best Practices fest.

Wie beschleunigt man die Verarbeitung gigabytegroßer Dateien: Wir teilen sie in Chunks (Chunking), nutzen positionellen Zugriff über FileChannel und memory-mapped Puffer MappedByteBuffer, parallelisieren die Berechnungen mit ExecutorService. Wir besprechen die Schlüsselmethoden des positionellen Ein-/Ausgabeverfahrens: position(...), read(...), write(...), Kriterien zur Wahl der Chunk-Größe, ein Beispiel für paralleles Zählen von Wörtern und typische Fehler (Chunk-Grenzen, Ressourcen, Anzahl der Threads).

Wir besprechen, wie man eine Pipeline zur Dateiverarbeitung nach dem Entwurfsmuster „Producer–Consumer“ mit sicherem Austausch über eine BlockingQueue (z. B. ArrayBlockingQueue) organisiert, wie die blockierenden Operationen put() und take() funktionieren, wozu der Mechanismus Backpressure dient und wie man Threads sauber mithilfe einer „poison pill“ beendet (z. B. "__END__", nicht null). Wir starten die Consumer über ExecutorService, fügen eine Visualisierung der Pipeline hinzu und schauen uns typische Fehler an.

Wir klären, warum Java 9 das modulare System JPMS gebracht hat: was an der „ classpath-Party“ problematisch ist, wie Module Sichtbarkeitsgrenzen auf Container-Ebene einführen, was module-info.java ist und wie man mit den Direktiven module, exports, requires, opens, uses/ provides arbeitet. Wir besprechen Vorteile (Kapselung, explizite Abhängigkeiten, Sicherheit, jlink), Einsatzorte (einschließlich java.base, java.sql), nützliche Feinheiten und typische Migrationsfehler (vergessenes exports, ausgelassenes requires, doppelte Modulnamen).