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
Daemon Threads | Overview
Java differenziert mitunter User-Threads und Daemon-Threads. Der Unterschied ist bedeutsam.
In einem Beispiel zeigen wir, wie man User- und Daemon-Threads erzeugt und was hierbei die Folgen für den Programmverlauf und die Ausführung der eigentlichen nebenläufige Programmschritte sind.
Thread
Daemon Threads | DaemonThreadDemo
Es gibt in Java zwei Typen von Threads: User-Threads und Daemon-Threads. In diesem Beispiel erzeugen wir beides.
package com.stuelken.java.b4.parallel.c03.threaddaemon;
/**
*
* @author t2m
*/
public class DaemonThreadDemo {
/**
*
* @param args Keine Argumente.
*/
public static void main(String[] args) {
// {#1} Worker definieren.
Thread worker = new Thread(() -> {
System.out.println("Worker beginnt und arbeitet 1.000ms");
try {
Thread.sleep(1000);
} catch (InterruptedException ignored) {
}
System.out.println("Worker beendet");
});
// {#2} Priorität zwischen 0 und 10 definieren beziehungsweise die Enumeration
// verwenden.
worker.setPriority(Thread.NORM_PRIORITY);
// {#3} Den Worker starten.
worker.start();
// {#4} Einen Daemon-Thread definieren
Thread daemon = new Thread(() -> {
while (true) {
System.out.println("Daemon beginnt und wird ca. 2.000ms arbeiten. ");
try {
Thread.sleep(2000);
} catch (InterruptedException ignored) {
}
System.out.println("Daemon hat geendet.");
}
});
// {#5} Dem Daemon-Thread mitteilen, dass es sich um einen Daemon-Thread
// handelt.
// Marks this thread as either a daemon thread or a user thread.
// The Java Virtual Machine exits when the only threads running are all daemon
// threads.
// This method must be invoked before the thread is started.
daemon.setDaemon(true);
// {#6} Den Daemon-Thread zuerst starten.
daemon.start();
// {#7} Den Daemon-Thread zuerst starten.
System.out.println("Letzte Zeile in main()");
}
}
//@formatting:off
/*
Worker beginnt und arbeitet 1.000ms
Daemon beginnt und wird ca. 2.000ms arbeiten.
Letzte Zeile in main()
Worker beendet
*/
Wichtig
Das Programm beendet sich, obwohl der Daemon weiterlaufen wollte – weil kein Nicht-Daemon-Thread mehr aktiv ist.
Wenn in einem Thread alle User-Threads beendet wurden und nur noch ausschließlich Daemon-Threads laufen, wird der Container-Thread beendet.
Ob ein Thread ein User- oder Daemon-Thread ist,
muss diesem über setDaemon(true)
vorher mitgeteilt werden.
Zusammenfassung
Daemon Threads | Zusammenfassung
Es gibt in Java zwei Typen von Threads: User-Threads und
Daemon-Threads. Man kann jeden Thread mit .setDaemon(true)
vor seinem Start in einen Daemon verwandeln.
Wenn in einem Thread alle User-Threads beendet wurden und nur noch ausschließlich Daemon-Threads laufen, wird der Container-Thread beendet.
Ob ein Thread ein User- oder Daemon-Thread ist,
muss diesem über setDaemon(true)
vorher mitgeteilt werden.
UIO3 Es ist einfacher als Du denkst.
Stelle noch heute Deine Anfrage.
