Java Concurrency in Practice

Einleitung

Das Buch „Java Concurrency in Practice“ (Autoren: Brian Goetz, Tim Peierls, Joshua Bloch u.a.) ist ohne Übertreibung die Bibel der Multithread-Programmierung in Java. 2006 erschienen, ist es bis heute die maßgeblichste und tiefgründigste Wissensquelle über Parallelität im Java-Ökosystem. Obwohl seit der Veröffentlichung fast zwei Jahrzehnte vergangen sind, sind die darin beschriebenen grundlegenden Prinzipien nicht veraltet: das Java Memory Model (JMM), Probleme der Sichtbarkeit, Atomarität, Ordnung sowie die Muster zur sicheren Objektveröffentlichung sind auch heute noch relevant.

Das Buch ist keine Einführung in Java von Grund auf – es setzt sichere Sprachkenntnisse und ein grundlegendes Verständnis von Threads voraus. Es macht jedoch aus einem Entwickler, der Threads „nur nutzt“, einen echten Experten, der in der Lage ist, zuverlässige, skalierbare und threadsichere Anwendungen zu entwerfen.

Worum geht es in diesem Buch

„Java Concurrency in Practice“ deckt alle wesentlichen Aspekte der parallelen Programmierung in Java ab – von Low-Level-Synchronisationsmechanismen bis hin zu High-Level-Abstraktionen aus dem Paket java.util.concurrent. Das Buch ist logisch aufgebaut: Zuerst werden die grundlegenden Probleme der Multithreading (Race Conditions, Deadlocks, Sichtbarkeitsprobleme) erläutert, dann werden die Werkzeuge zu ihrer Lösung behandelt – synchronized, volatile, final, atomare Variablen, ReentrantLock-Sperren, Semaphore, Barrieren. Eigene Kapitel widmen sich dem Testen von Multithread-Code, Leistung und Skalierbarkeit sowie fortgeschrittenen Themen wie Fork-Join und CompletionService.

Besonderes Augenmerk liegt auf dem Java Memory Model (JMM) – das Verständnis des JMM ermöglicht es dem Entwickler, schwer fassbare Fehler im Zusammenhang mit der Umordnung von Anweisungen und dem Zwischenspeichern von Daten zu vermeiden. Das Buch enthält zahlreiche Beispiele für „richtigen“ und „falschen“ Code, was den Stoff anschaulich und praxisnah macht.

Für wen ist dieses Buch

Das Buch richtet sich an erfahrene Java-Entwickler, die bereits mit Multithreading in Berührung gekommen sind und ihr Wissen systematisieren möchten. Es ist nützlich für:

• Entwickler von Serveranwendungen (Webdienste, Anfrageverarbeitung, Aufgabenwarteschlangen);
• Spezialisten für hochlastige Systeme und Low-Latency-Anwendungen;
• Architekten, die skalierbare Systeme entwerfen;
• Diejenigen, die sich auf technische Vorstellungsgespräche vorbereiten (insbesondere bei FAANG-Unternehmen);
• Dozenten und Autoren von Java-Kursen.

Anfängern mag das Buch anspruchsvoll erscheinen – es wird empfohlen, zunächst die Grundlagen der Multithreading aus anderen Quellen zu erlernen (z. B. „Thinking in Java“ von Bruce Eckel oder die offiziellen Oracle-Tutorials).

Was der Leser lernen wird

• Grundlegende Probleme der Multithreading: Race Conditions, Deadlocks, Starvation, Priority Inversion.
• Threadsicherheit: Wie man Klassen entwirft, die bei Zugriff aus mehreren Threads korrekt funktionieren.
• Java Memory Model (JMM): Happens-before-Regeln, Garantien für Sichtbarkeit, Atomarität und Ordnung.
• Sichere Objektveröffentlichung: Wie man ein Objekt für andere Threads sichtbar macht, ohne die Integrität zu verletzen.
• Synchronisationswerkzeuge: synchronized, volatile, ReentrantLock, ReadWriteLock, StampedLock.
• Atomare Klassen: AtomicInteger, AtomicReference, AtomicLong, AtomicReferenceFieldUpdater.
• Thread-Pool und Executor: ThreadPoolExecutor, ScheduledThreadPoolExecutor, ForkJoinPool.
• Sammlungen für Multithreading: ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue, ConcurrentLinkedQueue.
• Testen von Multithread-Code: Wie man Tests schreibt, die Rennbedingungen und Sperren aufdecken (einschließlich der Verwendung von Thread.yield() und Synchronisationsprimitiven).