Nebenläufige Programmierung mit Java

Nebenläufige Programmierung mit Java

by Jörg Hettel, Manh Tien Tran
Released September 2016
Publisher(s): dpunkt
ISBN: 97833864903694

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

umfassend, praxisorientiert, aktuell:- Konzepte werden verständlich und in praxisrelevanter Tiefe dargestellt- Autoren behandeln u.a. die erst mit Java 8 eingeführten Higher-level-Konzepte- Mit konkreten Fallbeispielen aus der Praxis

Table of contents

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

Product information

  • Title: Nebenläufige Programmierung mit Java
  • Author(s): Jörg Hettel, Manh Tien Tran
  • Release date: September 2016
  • Publisher(s): dpunkt
  • ISBN: 97833864903694