
Nebenläufige Programmierung mit Java
Description
Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.
More details
Other editions
Additional editions

Persons
Content
- Cover
- Titel
- Impressum
- Vorwort
- Inhaltsverzeichnis
- Kapitel 1: Einführung
- 1.1 Dimensionen der Parallelität
- 1.2 Parallelität und Nebenläufigkeit
- 1.2.1 Die Vorteile von Nebenläufigkeit
- 1.2.2 Die Nachteile von Nebenläufigkeit
- 1.2.3 Sicherer Umgang mit Nebenläufigkeit
- 1.3 Maße für die Parallelisierung
- 1.3.1 Die Gesetze von Amdahl und Gustafson
- 1.3.2 Work-Span-Analyse
- 1.4 Parallelitätsmodelle
- Teil I: Grundlegende Konzepte
- Kapitel 2: Das Thread-Konzept von Java
- 2.1 Der main-Thread
- 2.2 Erzeugung und Starten von Threads
- 2.2.1 Thread-Erzeugung durch Vererbung
- 2.2.2 Thread-Erzeugung mit Runnable-Objekten
- 2.3 Der Lebenszyklus von Threads
- 2.3.1 Beendigung eines Threads
- 2.3.2 Auf das Ende eines Threads warten
- 2.3.3 Aktives Beenden von Threads
- 2.3.4 Unterbrechung mit interrupt
- 2.3.5 Thread-Zustände
- 2.4 Weitere Eigenschaften eines Thread-Objekts
- 2.4.1 Thread-Priorität
- 2.4.2 Daemon-Eigenschaft
- 2.5 Exception-Handler
- 2.6 Zusammenfassung
- Kapitel 3: Konkurrierende Zugriffe auf Daten
- 3.1 Ein einleitendes Beispiel
- 3.2 Java-Speichermodell
- 3.2.1 Stacks und Heap
- 3.2.2 Speicher auf der Hardwareebene
- 3.2.3 Probleme mit gemeinsam nutzbaren Daten
- 3.2.4 Sequenzielle Konsistenz
- 3.2.5 Thread-sichere Daten und unveränderliche Objekte
- 3.3 Unveränderbare Objekte
- 3.4 Volatile-Attribute
- 3.5 Final-Attributte
- 3.6 Thread-lokale Daten
- 3.7 Fallstricke
- 3.8 Zusammenfassung
- Kapitel 4: Elementare Synchronisationsmechanismen
- 4.1 Schlüsselwort synchronized
- 4.1.1 Synchronized-Methoden
- 4.1.2 Synchronized-Blöcke
- 4.1.3 Beispiel: Thread-sicheres Singleton
- 4.1.4 Monitorkonzept bei Java
- 4.2 Fallstricke
- 4.3 Zusammenfassung
- Kapitel 5: Grundlegende Thread-Steuerung
- 5.1 Bedingungsvariablen und Signalisieren
- 5.2 Regeln zum Umgang mit wait, notify und notifyAll
- 5.3 Zusammenfassung
- Teil II: Weiterführende Konzepte
- Kapitel 6: Threadpools
- 6.1 Das Poolkonzept und die Klasse Executors
- 6.1.1 Executors mit eigener ThreadFactory
- 6.1.2 Explizite ThreadPoolExecutor-Erzeugung
- 6.1.3 Benutzerdefinierter ThreadPoolExecutor
- 6.2 Future- und Callable-Schnittstelle
- 6.2.1 Callable, Future und FutureTask
- 6.2.2 Callable, Future und ExecutorService
- 6.3 Callable und ThreadPoolExecutor
- 6.4 Callable und ScheduledThreadPoolExecutor
- 6.5 Callable und ForkJoinPool
- 6.6 Exception-Handling
- 6.7 Tipps für das Arbeiten mit Threadpools
- 6.8 Zusammenfassung
- Kapitel 7: Atomic-Variablen
- 7.1 Compare-and-Set-Operation
- 7.2 Umgang mit Atomic-Variablen
- 7.2.1 Atomic-Skalare
- 7.2.2 Atomic-Referenzen
- 7.3 Accumulator und Adder in Java 8
- 7.4 Zusammenfassung
- Kapitel 8: Lock-Objekte und Semaphore
- 8.1 Lock-Objekte
- 8.1.1 Das Lock-Interface
- 8.1.2 ReentrantLock
- 8.1.3 Das Condition-Interface
- 8.1.4 ReadWriteLock
- 8.1.5 StampedLock
- 8.2 Semaphore
- 8.3 Zusammenfassung
- Kapitel 9: Thread-sichere Container
- 9.1 Collection-Typen
- 9.2 Thread-sichere Collections
- 9.2.1 Synchronisierte Collections
- 9.2.2 Unmodifiable Collections
- 9.2.3 Concurrent Collections
- 9.3 Zusammenfassung
- Teil III: Ergänzende Synchronisationsmechanismen
- Kapitel 10: Exchanger und BlockingQueue
- 10.1 Exchanger
- 10.2 Queues
- 10.3 Das Erzeuger-Verbraucher-Muster
- 10.4 Varianten
- 10.4.1 Pipeline von Erzeugern und Verbrauchern
- 10.4.2 Erzeuger-Verbraucher-Muster mit Empfangsbestätigung
- 10.4.3 Erzeuger-Verbraucher-Muster mit Work-Stealing
- 10.5 Zusammenfassung
- Kapitel 11: CountDownLatch und CyclicBarrier
- 11.1 CountDownLatch
- 11.2 CyclicBarrier
- 11.3 Zusammenfassung
- Kapitel 12: Phaser
- 12.1 Das Konzept des Phasers
- 12.1.1 Phaser als CountDownLatch
- 12.1.2 Phaser als CyclicBarrier
- 12.2 Phaser als variable Barriere
- 12.3 Zusammenspiel mit dem ForkJoin-Threadpool
- 12.4 Zusammenfassung
- Teil IV: Parallelisierungsframeworks
- Kapitel 13: Das ForkJoin-Framework
- 13.1 Grundprinzip des ForkJoin-Patterns
- 13.2 Programmiermodell
- 13.2.1 Einsatz von RecursiveAction
- 13.2.2 Einsatz von RecursiveTask
- 13.2.3 Einsatz von CountedCompleter
- 13.3 Work-Stealing-Verfahren
- 13.4 Zusammenfassung
- Kapitel 14: Parallele Array- und Stream-Verarbeitung
- 14.1 Parallele Array-Verarbeitung
- 14.1.1 Parallele Transformation
- 14.1.2 Paralleles Sortieren
- 14.1.3 Parallele Präfixbildung
- 14.2 Funktionsprinzip der Stream-Verarbeitung
- 14.2.1 Funktionale Interfaces
- 14.2.2 Erzeugung von Streams
- 14.2.3 Transformations- und Manipulationsoperationen
- 14.2.4 Auswertungen von Streams
- 14.2.5 Eigenschaften und Operationsoptimierung
- 14.3 Parallele Stream-Verarbeitung: Datenparallelität
- 14.3.1 Arbeitsweise und korrekte Benutzung
- 14.3.2 Parallele Reduzierer
- 14.3.3 Parallele Collectoren
- 14.3.4 Funktionsweise von Spliteratoren
- 14.3.5 Benutzerdefinierte Spliteratoren
- 14.4 Zusammenfassung
- Kapitel 15: CompletableFuture
- 15.1 CompletableFuture als Erweiterung des Future-Patterns
- 15.2 Design von asynchronen APIs
- 15.2.1 Asynchrone APIs mit Future
- 15.2.2 Asynchrone APIs mit CompletableFuture
- 15.3 Asynchrone Verarbeitung: Task-Parallelität
- 15.3.1 Das Starten einer asynchronen Verarbeitung
- 15.3.2 Definition einer asynchronen Verarbeitungskette
- 15.4 Das Arbeiten mit CompletableFutures
- 15.4.1 Das Konzept des CompletionStage
- 15.4.2 Lineare Kompositionsmöglichkeiten
- 15.4.3 Verzweigen und Vereinen
- 15.4.4 Synchronisationsbarrieren
- 15.5 Fehlerbehandlung und Abbruch einer Verarbeitung
- 15.6 Zusammenfassung
- Teil V: Fallbeispiele
- Kapitel 16: Asynchrones Logging
- 16.1 Lösung mit Thread-lokalen Daten
- 16.2 Verbesserte Version (Exchanger)
- Kapitel 17: Datenstrukturen in Multithreaded-Umgebungen
- 17.1 Liste als sortierte Menge
- 17.2 Blockierende Lösungen (Locks)
- 17.2.1 Grobgranulare Synchronisierung
- 17.2.2 Feingranulare Synchronisierung
- 17.2.3 Optimistische Synchronisierung
- 17.3 Lockfreie Lösung (AtomicMarkableReference)
- Kapitel 18: The Dining Philosophers Problem
- 18.1 Basisalgorithmus
- 18.2 Lösungsvarianten (Semaphore und Lock)
- 18.2.1 Lösung mit einem Semaphor
- 18.2.2 Lösung mit asymmetrischer Lock-Anforderung
- 18.2.3 Lösung mithilfe eines Koordinators
- 18.2.4 Lösung mit asymmetrischer Wait-Release-Strategie
- Kapitel 19: Minimal aufspannende Bäume
- 19.1 Graphen und Spannbäume
- 19.2 Der Prim-Algorithmus
- 19.2.1 Funktionsweise des Algorithmus
- 19.2.2 Implementierung des Algorithmus
- 19.3 Parallelisierung (Phaser)
- Kapitel 20: Mergesort
- 20.1 Funktionsprinzip des Algorithmus
- 20.2 Parallelisierung (ForkJoin-Framework)
- Kapitel 21: Der k-Mean-Clusteralgorithmus
- 21.1 Der k-Mean-Algorithmus
- 21.2 Parallelisierung (Parallel Streams)
- 21.2.1 Datenmodell
- 21.2.2 Hilfsmethoden
- 21.2.3 Implementierung
- 21.2.4 Variante mit benutzerdefiniertem Collector
- Kapitel 22: RSA-Schlüsselerzeugung
- 22.1 Verfahren für die Schlüsselerzeugung
- 22.2 Parallelisierung (CompletableFuture)
- Kapitel 23: Threads bei JavaFX
- 23.1 Ein einfaches Beispiel
- 23.2 JavaFX-Concurrent-API
- Kapitel 24: Handler-Konzept bei Android
- 24.1 UI-Thread und nebenläufige Aktivitäten
- 24.2 Messages, Message-Queue, Looper
- 24.3 Handler
- Kapitel 25: Aktoren
- 25.1 Aktorenmodell
- 25.2 Beispielimplementierung mit Akka
- 25.2.1 Nachrichten
- 25.2.2 Beteiligte Aktoren
- 25.2.3 Starten der Anwendung
- Teil VI: Anhang
- A Ausblick auf Java 9
- A.1 Die Flow-Interfaces
- Literaturverzeichnis
- Index
- Fußnoten
- Kapitel 1: Einführung
- Kapitel 2: Das Thread-Konzept von Java
- Kapitel 3: Konkurrierende Zugriffe auf Daten
- Kapitel 4: Elementare Synchronisationsmechanismen
- Kapitel 6: Threadpools
- Kapitel 7: Atomic-Variablen
- Kapitel 8: Lock-Objekte und Semaphore
- Kapitel 13: Das ForkJoin-Framework
- Kapitel 14: Parallele Array- und Stream-Verarbeitung
- Kapitel 15: CompletableFuture
- Kapitel 18: The Dining Philosophers Problem
- Kapitel 19: Minimal aufspannende Bäume
- Kapitel 20: Mergesort
- Kapitel 22: RSA-Schlüsselerzeugung
- Kapitel 24: Handler-Konzept bei Android
- Kapitel 25: Aktoren
- Kapitel A: Ausblick auf Java 9
System requirements
File format: PDF
Copy protection: Watermark-DRM (Digital Rights Management)
System requirements:
- Computer (Windows; MacOS X; Linux): Use the free software Adobe Reader, Adobe Digital Editions, or any other PDF viewer of your choice (see eBook Help).
- Tablet/Smartphone (Android; iOS): Install the free app Adobe Digital Editions or another reading app for eBooks, e.g., PocketBook (see eBook Help).
- E-reader: Bookeen, Kobo, Pocketbook, Sony, Tolino and many more (only limited: Kindle).
The file format PDF always displays a book page identically on any hardware. This makes PDF suitable for complex layouts such as those used in textbooks and reference books (images, tables, columns, footnotes). Unfortunately, on the small screens of e-readers or smartphones, PDFs are rather annoying, requiring too much scrolling.
This eBook uses Watermark-DRM, a „soft” copy protection. This means that there are no technical restrictions to prevent illegal distribution. However, there is a personalised watermark embedded in the eBook that can be used to identify the purchaser of the eBook in the event of misuse and to provide evidence for legal purposes.
For more information, see our eBook Help page.