: Angelika Langer, Klaus Kreft
: Java Core Programmierung Memory Model und Garbage Collection
: entwickler.press
: 9783868022629
: 1
: CHF 15.30
:
: Programmiersprachen
: German
: 250
: DRM
: PC/MAC/eReader/Tablet
: PDF
Für Java-Entwickler sind nicht nur die Sprachelemente der Programmiersprache Java und die umfangreichen Bibliotheken des JDK (Java Development Kit) von Bedeutung; auch die Ablaufumgebung (JVM = Java Virtual Machine) ist relevant für die Software-Entwicklung in Java. Das vorliegende Buch 'Java Core Programmierung' befasst sich mit zwei grundlegenden und wichtigen Aspekten der Java-Ablaufumgebung: dem Java Memory Model (JMM) und der Freispeicherverwaltung (Garbage Collection.) Beim Java Memory Model geht es um die Regeln und Garantien für konkurrierende Zugriffe auf Java-Objekte in Multithread-Programmen. Es werden u.a. folgende Fragestellungen betrachtet: Wann und unter welchen Umständen werden Modifikationen, die ein Thread an einem Java-Objekt gemacht hat, anderen Threads sichtbar? Was genau ist der Effekt von Sprachmitteln wie synchronized, volatile und final? Was ist eine CAS-Operation? Wofür werden atomare Variablen benötigt? Was ist Lock-Free-Programming und warum könnte es mich als Java-Entwickler interessieren? Schon seit Langem ist das Memory Model Bestandteil der Sprachspezifikation von Java. Es ist aber viele Jahre lang wenig beachtet worden. Erst seit Multi-CPU- und Multicore-Plattformen vorherrschend sind, gewinnt das Wissen über die Details des Memory Models an Bedeutung. Detaillierte Kenntnisse des Memory Models sind unerlässlich für alle Java-Entwickler, die Java-Anwendungen für Multi-CPU- und Multicore-Hardware entwickeln und sich mit der Optimierung dieser Anwendungen hinsichtlich Skalierbarkeit und Performanz befassen. Zwar geht es auch beim Thema Freispeicherverwaltung um den 'Speicher', aber mit dem Java Memory Model hat die Garbage Collection nichts zu tun. Es geht vielmehr um die Strategien, die eine virtuelle Maschine anwendet, um den im Programm mit new angeforderten Freispeicher zu verwalten und ihn wieder frei zu geben, wenn er nicht mehr benötigt wird. Virtuelle Maschinen verwenden dazu unterschiedliche Algorithmen. Im vorliegenden Buch werden die Garbage-Collection-Algorithme der populären HotSpot-JVM von Sun (heute Oracle) betrachtet. Es wird erläutert, warum Generational Garbage Collection sinnvoll ist, wie die HotSpot-JVM den Freispeicher aufteilt und wie die parallelen und konkurrierenden Garbage-Collection-Algorithme funktionieren. Auch der relativ neue 'Garbage-First' (G1) Collector wird vorgestellt. Ein wesentliches Augenmerk liegt dabei auf dem Tuning dieser zahlreichen Garbage-Collection-Algorithme . Es lohnt sich beispielsweise zu prüfen, wie viel von der gesamten CPU-Zeit einer Java-Applikation für die Garbage-Collection aufgewendet werden muss. Idealerweise möchte man einen möglichst hohen Durchsatz haben, d.h. es soll viel CPU-Zeit für die Anwendung zur Verfügung stehen und nur wenig Zeit für die Freispeicherverwaltung aufgewendet werden. Auch sollte die Garbage Collection nicht zu störenden Pausen führen, in denen sämtliche Applikations-Threads zum Zwecke der Garbage Collection angehalten werden. Um die Maximierung des Durchsatzes und die Minimierung der Pausenzeiten zu erreichen, bietet die HotSpot-JVM zahlreiche Tuning-Möglichkeiten. Das Buch basiert auf einer Artikelserie, die die Autoren im Java Magazin in den Jahren 2008 bis 2011 veröffentlicht haben. Weitere Beiträge der Artikelreihe sind unter http://www.angelikalanger.com Articles/EffectiveJava.html zu finden.

Angelika Langer arbeitet als Trainer und Consultant mit eigenem Schulungsprogramm im Bereich der Software-Entwicklung mit Java und C++. Sie ist Autor der Java Generics FAQs, einer Online-Ressource zum Thema Java Generics. Sie ist regelmäßiger Sprecher auf zahlreichen Konferenzen, darunter JavaOne, OOPLSA, JAX, und viele andere. Klaus Kreft arbeitet als Consultant und Performance-Experte im Bereich der Software-Entwicklung mit Java. Sein Interesse gilt komplexen Systemen mit hohen Performance-Anforderungen. Er ist Sprecher auf Fachkonferenzen (JAX, OOP, Ch/Open-Workshop-Tage und diverse JUGs). Gemeinsam sind sie Autor zahlreicher Veröffentlichungen, darunter einer Artikelserie über Core Java Programmierung in der Zeitschrift JavaMagazin und das Buch 'Standard C++ IOStreams and Locales', erschienen bei Addison-Wesley, 2000.
Inhaltsverzeichnis4
Vorwort12
A – Java-Memory-Modell 14
Kapitel 1 – Einführung in das Java-Memory-Modell 18
1.1 Atomare Zugriffe 20
1.2 Sequential Consistency 21
1.3 Sichtbarkeitsregeln für volatile-Variablen 22
1.4 Sichtbarkeitsregeln für Synchronisation 23
1.5 Zusammenfassung 25
Kapitel 2 – Das Java-Memory-Modell im Überblick 26
2.1 Das Java-Memory-Modell 27
2.2 Sichtbarkeitsregeln im JMM 29
2.3 Zusammenfassung 33
Kapitel 3 – Die Kosten der Synchronisation 34
3.1 Performanceeinbußen durch Synchronisation 35
3.2 Skalierbarkeitseinbußen durch Synchronisation 36
3.3 Sequenzialisierung bekämpfen 41
3.4 Zusammenfassung 44
Kapitel 4 – Details zu volatile-Variablen 46
4.1 volatile als Alternative zur Synchronisation 46
4.2 Missverständnis 49
4.3 Kosten von volatile 51
4.4 Speichereffekte von volatile auf andere Variablen 52
4.5 volatile-Referenzvariablen 55
4.6 Zusammenfassung 59
Kapitel 5 – volatile und das Double-Check-Idiom 60
5.1 Ausgangssituation 60
5.2 Das Double-Check-Idiom 61
5.3 Optimierung à la Bloch 64
5.4 Single-Check-Idiome 67
5.5 Zusammenfassung 71
Kapitel 6 – Regeln für die Verwendung von volatile 72
6.1 Effekte von Synchronisation 72
6.2 Regeln für den Einsatz von volatile 74
6.3 Beispiele für den erfolgreichen Einsatz von volatile 76
6.4 Zusammenfassung 83
Kapitel 7 – Die Initialisation-Safety-Garantie 84
7.1 Das Racy-Single-Check-Idiom 84
7.2 Anforderungen an unveränderliche 87
7.3 Speichereffekte im Zusammenhang mit final-Feldern 88
7.4 Unterschiede zu volatile 97
7.5 final Variablen vs. final Felder 97
7.6 Zusammenfassung 99
Kapitel 8 – Über die Gefahren allzu aggressiver Optimierungen 100
8.1 Racy-Single-Check und unveränderlichen Typen 100
8.2 Genereller Verzicht auf Synchronisation/volatile bei unveränderlichen Typen? 102
8.3 Race Conditions bei der Konstruktion von Objekten 105
8.4 Zusammenfassung 110
Kapitel 9 – Atomic Scalars 112
9.1 Ein Thread-sicherer Zähler mit Synchronisation 113
9.2 CAS - Compare and Swap 114
9.3 Ein Thread-sicherer Zähler unter Verwendung von atomaren Variablen 115
9.4 Zusammenfassung 117
Kapitel 10 – Atomare Referenzvar