JAVA-B4
Parallel Computing (Parallelism)
Parallelism
Multithreading
Klassische Threads
Threads & Runnables
Overview
Thread (Begriff)
DruckThread
DruckRunnable
ThreadDemo
Output
Thread Lifecycle
Overview
start()
run()
join()
stop()?
StartRunJoinDemo Example
Von allein endende Threads
Threads mit while(criteria)
Daemon-Threads
Overview
ThreadDaemonDemo
Daemon (Summary)
Thread-Priority
Overview
t.setPriority(..)
MachineThread Klasse (Example)
ThreadPriorityDemo (Example)
Thread Notification
Grundlagen
wait
notify
notifyAll
sleep
sleep vs. wait
Thread Notification Demo
sychronized(monitor)
Notification/Monitor Zusammenfassung
Concurrent API
Vom Thread zur Concurrent API
Was ist Concurrency?
Was ist Concurrency?
Problemstellungen bei herkömmlichen Threads
Features der Concurrent API
Warum: Bedeutung des Umstiegs
Themenüberblick
Technischer Hintergrund
Thread.sleep(0, 500_000)
System.nanoTime()
Executors (Übersicht) #310
ExecutorService (Page)
Begriffsbestimmung
Excetutor
.execute()
ExecutorService (Begriff)
ExecutorService Interface Methoden
Mehrere Callables und Runnables auf einmal starten
Kontrolliertes Beenden
Executors-Utilily Klasse
newCachedThreadPool()
newSingleThreadExecutor()
newFixedThreadPool(int nThreads)
newWorkStealingPool()
newScheduledThreadPool(int corePoolSize)
Beispiel
ForkJoinPool, RecursiveTask, Executors Example#09
A | B1,B2,B3 | C mit Summenbildung.
Executor vs. ExecutorService Example#10
Executors.newFixedThreadPool(2)
Beispiel
Zusammenfassung Executors
Callable, Future #330
Callable Future (Begriff)
Callable Interface (Begriff)
Begriff
Callable erzeugen
Callable verwenden
Future
Beispiel
Future-Listen mit invokeAll
Was sind Future-Listen?
Wie erzeuge ich Future-Listen?
Wann blockt eine Future-Liste?
Beispiel mit 12 Callables in 4 Gruppen
Executors (#350) @! Bis auf Hinweis doppelt
Overview
Executor (Begriff)
ExecutorService (Begriff)
Executors.new~ Factory Methoden
Executors für ThreadPoolExecutor mit fixed Pool
ScheduledExecutorService
ScheduledExecutorService
Superklasse ExecutorService
schedule(*)
scheduleAtFixedRate(*)
scheduleWithFixedDelay(*)
ScheduledExecutorService (xmpl)
ProductClock(Main, Bsp.)
AbstractMachine**
AbstractMaterial**
Coal/Iron/Steel**
Coal-/Iron-/Steel-Machine**
Material**
ProductionBus-Machine**
Storage T**
ThreadPoolExecutor (Detail)
Executor Implementierung
ThreadPoolExecutor (Term)
ThreadPoolExecutor Beispiele
"FixedSizeExecutorExample" EXAMPLE C20
"CachedExecutorExample" EXAMPLE C21
SynchronousQueue
"ScheduledExecutorExample" EXAMPLE C22
"CustomSingleThreadExecutorRunnableComponent" EXAMPLE C23
"CustomPolicyRejectedExecutorExample" EXAMPLE C24
"PrioritizedCombinerRunnableComponent" EXAMPLE C30
"BufferingRejectedTasksExample" EXAMPLE C31
Java RejectedExecutionHandler
ThreadPoolExecutor FAQ
Synchronizer
Synchronizer (overview)
Synchronizer Begriff
CountDownLatch
CountDownLatch Example
CyclicBarrier
CyclicBarrier Example (@Zeit ausgeben!)
Phaser
Phaser Example(@Erl!)
Exchanger
Exchanger ping/pong
Semaphore
CompletableFuture
async!!!
SemaphoreCompletableFutureDemo (@!?)
Monitoring
JMX
ThreadPoolExecutor "live" überwachen
getActiveCount()
getPoolSize()
getCompletedTaskCount()
getQueue().size()
Concurrency
Example:DeterministicCopy @todo FILE LINK FEHLT!
Example:NonDeterministicCopy @todo FILE LINK FEHLT!
Kapitel java.util.concurrent.Flow @!fehltReactive Flow @!fehltPublisher TSubscriber TSubscription TProcressor TProcressor T
Overview
Concurrency Intro | Overview
Die Java Concurrency API erweitert maßgeblich das Erstellen, Verwalten und das Monitoring von Threads. Die Verwaltung über Executors, Tasks, Pools, Scheduler und mehr macht vieles einfacher. Die Voraussetzung besteht allerdings darin, dass man zuerst einmal versteht, welchen Typ an parallelen Architekturen man mit welchem Ansatz realisieren kann.
Bevor wir uns im Detail mit den jeweiligen Features befassen geben wir zu Beginn einen Einblick und Überblick, warum, wo und ab wann man diese Techniken einsetzen und herkömmliche Verfahren mit klassischen Threads überarbeiten sollte. Unsere Intro für den Sprung von Threads zu Concurrency API.
«Was ist Concurrency»
Concurrency | Was ist ...
Was istConcurrency?
Concurrency beschreibt die Fähigkeit eines Programms, mehrere Aufgaben zeitlich versetzt oder gleichzeitig zu bearbeiten.
Was es bisher??
In der Java-Welt war Multithreading und Parallel-Computing lange Zeit eng mit der Thread-Klasse verknüpft.
Entwickler mussten jeden Thread manuell erzeugen, starten und kontrollieren. Bei wachsender Komplexität wurde jedoch deutlich, dass es strukturiertere Ansätze braucht.
Abstraktion von Thredas, Executor-Modelle, Callables mit Rückgabe und mehr.
Die java.util.concurrent API bietet seit Java 5 eine moderne Lösung für nebenläufige Programmierung:
Sie abstrahiert Threads.
Sie bietet Executor-Modelle.
Es werden Callables mit Rückgabe unterstützt.
Man hat mit Future, Synchronisierer und Locks eine robustere Grundlage für skalierbare Systeme geschaffen.
Bedeutung des Umstiegs
Concurrency | Bedeutung des Umstiegs
Warum ist der Umstieg auf java.util.concurrent so wichtig?
Klassisches Thread-Management ist fehleranfällig:
unkontrollierter Start, keine Poolverwaltung, schwierige Fehlerbehandlung. :
Die Concurrent-API stellt sicher
-
Automatisierte Thread-Pools durch
ExecutorService -
Sauberere Trennung zwischen Aufgaben und Ausführung
-
Asynchrone Kommunikation mit
FutureundCallable -
Zuverlässige Synchronisation durch
CountDownLatch,Semaphoreund mehr -
Monitoring und Skalierung mit
ThreadPoolExecutorundJMX
Themen dieses Kapitels
Concurrency | Themen dieses Kapitels
Themen dieses Kapitels
In diesem Bereich von JAVA-B4 behandeln wir die folgenden Themen und Begriffe:
-
Executor und ExecutorService
-
Callable, Future und Rückgabewerte
-
ThreadPoolExecutor mit Queues und Prioritäten
-
ScheduledExecutorService als Taktgeber
-
Synchronisierer:
CountDownLatch,CyclicBarrier,Phaser -
Concurrent Collections wie
ConcurrentHashMap -
Atomare Variablen:
AtomicInteger,LongAdder
UIO3 Es ist einfacher als Du denkst.
Stelle noch heute Deine Anfrage.