Threadnocchio Dietrich Boles Nachdenken in Aurich 2009 Spielerisches Erlernen der parallelen Programmierung mit Java-Threads Dietrich Boles

Gliederung Java-Threads vor Java 5 Java-Threads seit Java 5 Scheduling syncronized wait-notify Java-Threads seit Java 5 Sperren Atomare Variablen Queues Nützliche Synchronisationsklassen Thread-Pools Einführung in das Arbeiten mit Threadnocchio Praktisches Arbeiten mit Threadnocchio

Java-Threads Klasse java.lang.Thread public class ThreadKlasse extends Thread { private String str; public ThreadKlasse(String s) { this.str = s; } public void run() { while (true) System.out.println(this.str); } public static void main(String[] args) { ThreadKlasse hallo = new ThreadKlasse("hallo"); ThreadKlasse dibo = new ThreadKlasse("dibo"); hallo.start(); dibo.start(); } ( 1-threads-startrek)

Thread-Zustände blockiert deblockieren (synchronized-Ende, sleep-Ende, Thread-Ende, notify, EA-Ende, interrupt) blockieren (synchronized, sleep, join, wait, EA) zuordnen erzeugt bereit beendet rechnend start() Ende von run verdrängen, yield()

Scheduling static int activeCount() static int enumerate(Thread[] tarray) static Thread currentThread() Thread.State getState() // NEW, TERMINATED, WAITING, … void setPriority(int priority) // wenig sinnvoll int MIN_PRIORITY, int MAX_PRIORITY, int NORM_PRIORITY static void yield() // in Zustand bereit static void sleep(long milliSekunden) // blockieren void join() // auf Ende warten void interrupt() // sleep, join unterbrechen void setDaemon(boolean on) // Garbage-Collector

Kommunikation Kommunikation = Datenaustausch über gemeinsame Variablen bzw. Objekte möglich, da sich Threads einen gemeinsamen Adressraum teilen Probleme bei der Nutzung gemeinsamer Variablen Nicht-determinierte Ergebnisse durch Races (Wettrennen) Schreib/Schreibkonflikte Schreib/Lesekonflikte „Kritische Abschnitte“ Lösung: Synchronisation = Ordnung der Abfolge bestimmter Aktivitäten mehrerer Threads Synchronisationsarten: mehrseitige Synchronisation einseitige Synchronisation

synchronized  2-mssync-elefanten jedes Objekt besitzt Sperre (Lock) Sperren können implizit gesetzt bzw. freigegeben werden synchronized-Anweisung: synchronized (<Objektreferenz>) // Sperr-Objekt <Anweisung> // Kritischer Abschnitt synchronized-Methoden synchronized void m() { /* krit Abschnitt */ } entspricht: void m() { synchronized (this) { /* krit Abschnitt */ } }  2-mssync-elefanten

wait-notify (1) Problem: Bestimmte Anweisungen sollen nur dann ausgeführt werden, wenn anwendungsabhängige Bedingungen erfüllt sind; ansonsten warten (und zwar nicht aktiv!) public class Object { public final void wait() // passives Warten public final void notify() // wecken (eines Threads) public final void notifyAll() // wecken aller }

wait-notify (2) synchronized (obj) { while (!bedingung) obj.wait(); } Voraussetzung: Lock von obj ist gesetzt ( synchronized) Aufrufender Thread wird blockiert Lock von obj wird frei gegeben bedingung erfüllen; obj.notify(); Irgendein Thread T1, der auf obj wartet, wird in den Zustand bereit versetzt (notifyAll  alle) T1 muss erst wieder Lock setzen, bevor er fortfahren kann  3-essync-baby

Semaphore (1) Java: synchronized-Anweisung Nachteile: Block-gebunden Kein Hand-over-Locking möglich Thread-gebunden Exklusiv Lösung: Semaphore // Thread 1 // Thread 2 sem.p(); sem.p(); // kritischer Abschnitt // kritischer Abschnitt sem.v(); sem.v();

Semaphore (2) public class Semaphor { private int freiePlaetze; public Semaphor(int maximalFreiePlaetze) { if (maximalFreiePlaetze < 0) this.freiePlaetze = 0; else this.freiePlaetze = maximalFreiePlaetze; } public synchronized void p() { while (this.freiePlaetze == 0) { try { this.wait(); } catch (InterruptedException exc) {} this.freiePlaetze--; public synchronized void v() { this.freiePlaetze++; this.notify();

Semaphore (3) package java.util.concurrent; class Semaphore { // seit Java 5 public Semaphore(int permits) public Semaphore(int permits, boolean fair) public void acquire() throws InterruptedException public void acquireUninterruptibly() // p public boolean tryAcquire() public void release() // v ... }  4-semaphore-elefanten

Locks(1) synchronized: implizite Sperren Locks: explizite Sperren (seit Java 5) public interface Lock { public void lock(); public void unlock(); public Condition newCondition() } public interface Condition { public void await() throws InterruptedException public void signal() public void signalAll() public class ReentrantLock implements Lock { ... }

Locks(2) Lock sperre = new ReentrantLock(); Condition bedingung = sperre.newCondition(); sperre.lock(); try { ... bedingung.await(); // auf Erfülltsein warten } finally { sperre.unlock(); } bedingung.signal(); // Erfülltsein signalisieren  5-locks-baby

ReadWriteLocks ReadWriteLocks: Lösung für Reader-Writer-Problem ReadLock: mehrere Threads WriteLock: exklusive Sperre public interface ReadWriteLock { public Lock readLock() public Lock writeLock() } public class ReentrantReadWriteLock implements ReadWriteLock  6-rwlocks-elefanten

Atomare Variablen (1) Klassen für atomare Variablen der Standarddatentypen keine Sperren notwendig class Konto { int kontostand1 = 0; AtomicInteger kontostand2 = new AtomicInteger(0); synchronized int einzahlen1(int betrag) { return kontostand1 = kontostand1 + betrag; } int einzahlen2(int betrag) { return this.kontostand.addAndGet(betrag);

Atomare Variablen (2) package java.util.concurrent.atomic; public class AtomicInteger extends java.lang.Number { public AtomicInteger(int initialValue) public final void set(int newValue) public final int get() public final boolean compareAndSet(int exp, int update) public final int addAndGet(int delta) public final int getAndIncrement() public final int getAndDecrement() public final int getAndAdd(int delta) ... }

Queues Interfaces Klassen  7-queues-baby Queue (add, element, remove, …) BlockingQueue (put, poll, …) Deque (addFirst, addLast, …) BlockingDeque (offerFirst, offerLast, …) Klassen ArrayBlockingQueue<E> (begrenzt) LinkedBlockingQueue<E> (unbegrenzt) LinkedBlockingDeque<E> (unbegrenzt) SynchronousQueue<E> (Übergabe on-the-fly) PriorityBlockingQueue<E> (Lieferung gemäß Prioritäten) DelayQueue<E extends Delayed> (Objekte bestimmen Verweildauer) …  7-queues-baby

Exchanger Welchselseitiger Austausch von Objekten zwischen Threads package java.util.concurrent; public class Exchanger<V> { public Exchanger() public V exchange(V data) throws InterruptedException }  8-exchanger-baby (ohne Lösung)

CountDownLatch Realisierung von Count-Downs package java.util.concurrent; public class CountDownLatch { public CountDownLatch(int initCount) public void await() throws InterruptedException public void countDown() ... }  9-countdown-animals

CyclicBarrier Realisierung von Sammelpunkten package java.util.concurrent; class CyclicBarrier { public CyclicBarrier(int anzahl) public int await() throws InterruptedException, BrokenBarrierException ... }  10-barriers-animals

FutureTask Threads, die Ergebnisse liefern public interface Callable<V> { public V call() throws Exception; } public class FutureTask<V> implements Runnable { public FutureTask(Callable<V> callable) public V get() throws InterruptedException, ExecutionException // ...

Thread-Pooling (1) Threads „auf Vorrat“ class ThreadPoolExecutor implements ExecutorService { public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) public void execute(Runnable command) ... } public class Executors { public static ExecutorService newCachedThreadPool() public static ExecutorService newFixedThreadPool(int maxThreads) // ...

Thread-Pooling (2) int ANZAHL_AUFTRAEGE = 5; int ANZAHL_GLEICHZ_THREADS = 2; ExecutorService dienstleister = Executors .newFixedThreadPool(ANZAHL_GLEICHZ_THREADS); for (int i = 0; i < ANZAHL_AUFTRAEGE; i++) { dienstleister.execute(<Runnable.auftrag>); } dienstleister.shutdown();

Arbeiten mit Threadnocchio

Aufgaben Passt das Stück „Exchanger“ so an, dass Kauffrauen und Mütter an der Kasse Essen gegen Geld tauschen! Versucht einmal, die Klasse Exchanger mit den Java-1.4-Standardmechanismen selbst zu implementieren!