Lektionen

In der Vorlesung behandeln wir, was eine gegenseitige Blockierung von Threads (Deadlock) in Java ist, warum sie auftritt und welche vier Bedingungen dafür nötig sind. An einem praktischen Beispiel mit synchronized zeigen wir die Reproduktion des Problems und lernen anschließend Präventionsstrategien: einheitliche Reihenfolge beim Erfassen von Ressourcen, Einsatz von ReentrantLock.tryLock mit Timeout, Verkürzung kritischer Sektionen und Verzicht auf unnötig verschachtelte Sperren. Wir demonstrieren die Diagnose per Thread Dump und jstack, wie man die Zustände BLOCKED/ WAITING erkennt, und schließen mit einer Checkliste und typischen Fehlern ab.

Wir betrachten die nebenläufigen Anomalien Livelock und Starvation: wie sie sich von Deadlock unterscheiden, wie sie im Code und in Logs aussehen. Gezeigt werden Beispiele in Java: „höfliche Arbeiter“ (lebendige Blockierung) sowie Verhungern durch Prioritäten und aufgrund unfairer Sperren. Wir lernen, das Problem zu erkennen (Logging, Thread dump, VisualVM, Java Mission Control) und es zu verhindern: zufällige Verzögerungen vor einem erneuten Versuch ( Thread.sleep), nicht blockierende Algorithmen, faire Sperren via ReentrantLock mit dem Flag fairness ( new ReentrantLock(true)), saubere kritische Abschnitte und Verzicht auf übermäßige Nutzung von setPriority() und synchronized.

In dieser Vorlesung schauen wir uns an, warum gewöhnliche Collections ( ArrayList, HashMap) in einer Multithreading-Umgebung gefährlich sind und welche thread-sicheren Alternativen das Paket java.util.concurrent bietet: ConcurrentHashMap, CopyOnWriteArrayList, ConcurrentLinkedQueue, Strukturen auf Basis von Skip-Lists und BlockingQueue. Wir besprechen atomare Operationen wie merge, putIfAbsent, computeIfAbsent, vergleichen mit Collections.synchronizedMap, betrachten praktische Beispiele und typische Fehler (schwach konsistente Iteratoren, nicht atomare Operationssequenzen usw.).

Warum der Inkrementoperator i ++ in der Nebenläufigkeit nicht funktioniert, was atomare Operationen sind und wie das Paket java.util.concurrent.atomic sie bereitstellt. Wir beleuchten AtomicInteger und AtomicReference, die Methoden incrementAndGet(), compareAndSet(...), den internen Mechanismus CAS (Compare-And-Swap) sowie wann man besser synchronized wählt und wann — LongAdder. Am Ende — typische Fehler: zusammengesetzte Operationen, ABA und Threadsicherheit verschachtelter Objekte.

Wie man einen Thread Dump mithilfe von jstack, VisualVM und der IDE aufnimmt und liest, Thread-Zustände ( RUNNABLE, BLOCKED, WAITING) erkennt und gegenseitige Blockierungen findet. Wir betrachten das Thread-Monitoring in Java Mission Control und Java Flight Recorder, Logging-Praktiken (Thread-Namen, Ein-/Austritt aus synchronized), die Minimierung von Sperren, Concurrency-Tests mit CountDownLatch sowie die Analyse eines realen Deadlock-Falls. Zum Schluss – typische Fehler und wie man sie vermeidet.

In dieser Vorlesung betrachten wir den Unterschied zwischen Nebenläufigkeit und Parallelität: wo Reaktionsfähigkeit wichtig ist und wo – echte Beschleunigung auf mehreren Kernen. Wir besprechen das Erstellen von Threads über Thread, die Implementierung von Runnable und High-Level-Pools wie ExecutorService, sehen uns ein einfaches Beispiel der Array-Summation an, klären, wann Parallelität hilft und wann sie schadet, sowie typische Probleme: Datenrennen, Synchronisation über synchronized, Deadlocks und Lastverteilung. Am Ende – eine Vergleichstabelle und eine Visualisierung von Szenarien.

Praxis der Nebenläufigkeit wie bei den Profis: Wir übergeben Aufgaben an ExecutorService statt Threads per Hand mit Thread zu erstellen, steuern Pool, Warteschlange und Lebenszyklus ( shutdown(), shutdownNow()). Wir erläutern den Unterschied zwischen Runnable und Callable<T>, holen Ergebnisse über Future und dessen Methoden ( get(), isDone(), cancel(...), isCancelled()). Wir zeigen das Starten mehrerer Aufgaben, invokeAll/ invokeAny, die Behandlung von ExecutionException und typische Fehler.

Wir klären, wie man einen gewöhnlichen Datenstrom mit nur einer Zeile auf parallele Verarbeitung umstellt – über parallelStream() oder .parallel(), was unter der Haube in ForkJoinPool.commonPool() passiert, wann Parallelität Berechnungen tatsächlich beschleunigt (große Kollektionen, „schwere“ Operationen) und wo sie bremsen kann. Wir zeigen Beispiele für Filterung, Aggregation, Sortierung, Performance-Messung und gehen typische Fehler durch: Seiteneffekte in forEach, Erhalt der Reihenfolge, Wahl der Kollektionen und das Einstellen des Parallelitätsgrads.

Praktischer Leitfaden zu parallelen Berechnungen in Java: wie der Aufgabenpool ForkJoinPool und die rekursiven Aufgaben RecursiveTask<T>/ RecursiveAction funktionieren, warum der Work-Stealing-Algorithmus nützlich ist, wie man Aufgaben mit fork() aufteilt und die Ergebnisse mit join() innerhalb von compute() zusammenführt. Wir schauen uns den Start über pool.invoke() an, ein Beispiel zur Arraysumme und zur Maximumsuche, die Rolle des ForkJoinPool in parallelStream() sowie typische Fehler und wie man sie vermeidet.

Praktischer Leitfaden zur Parallelprogrammierung in Java: wann es sinnvoll ist, ExecutorService zu verwenden, wobei parallelStream hilft und für welche Aufgaben ForkJoinPool benötigt wird. Wir besprechen Thread-Safety mit ConcurrentHashMap/ CopyOnWriteArrayList und atomaren Klassen ( AtomicInteger), Performance-Messungen mit System.nanoTime() und JMH, die Fehlerbehandlung aus Future.get() und ForkJoinTask, den korrekten Umgang mit InterruptedException sowie Logging-Tricks ( Thread.currentThread().getName()) und Testen ( Awaitility). Am Ende – eine Auswahltabelle für Werkzeuge und typische Fehler.

Wir beleuchten das Starten und die Komposition asynchroner Berechnungen mit CompletableFuture: wie man Aufgaben über supplyAsync und runAsync startet, worin sich die Handler thenApply, thenAccept, thenRun unterscheiden und wann man deren asynchrone Varianten thenApplyAsync/ thenAcceptAsync/ thenRunAsync wählt. Wir sprechen über Ausführungs‑Threads ( ForkJoinPool oder Ihr Executor), Ergebnis‑Typen ( CompletableFuture<T>, CompletableFuture<Void>) und typische Fehler: blockierende get()/ join(), unbehandelte Fehler ohne exceptionally/ handle/ whenComplete sowie der Versuch, das Ergebnis innerhalb von thenRun zu verwenden.