Parallel Programming Semaphores / Reader - Writer - Lock

Übersicht 1. Semaphores 1. Semaphores in der Theorie 2. Semaphores in Java 3. Semaphores und Monitors 2. Reader - Writer - Lock

1. SEMAPHORS 1. Seamphores in der Theorie

Semaphore, Definition Konstrukt zur Synchoronisierung von parallelen Abläufen. Stellt zwei Operationen zur Verfügung P()(“Passeren”, Acquire, Up) V()(“Vrijgeven”, Release, Down)

Semaphore, Varianten Binäre Semaphore  Hat nur zwei Zustände ( offen - zu, frei - besetzt, etc.) Counting ( General ) Semaphore  Hat eine bestimmte, endliche Anzahl “Slots”, die via p() “besetzt” und mit v() “freigegeben” werden können.

Semaphore, Verhalten p(), aquire(), up() WENN kein “Slot” frei ist, DANN warte bis ein “Slot” frei ist markiere den “Slot” als besetzt und fahre fort v(), release(), down() markiere einen “Slot” als frei

1. SEMAPHORES 2. Semaphores in Java

Semaphore in Java import java.util.concurrent.Semaphore; // 2 Konstruktoren public Semaphore(int maxAvailable); //default: not fair public Semaphore(int maxAvailable, boolean fair); //Binary Semaphore: new Semaphore(1, fair); public void acquire(); public void acquire(int permits); public void release(); public void release(int permits); // und andere… Vorsicht : tryAcquire(…) ist immer unfair !

Semaphores, Beispiel public class Account { int balance = 0; Semaphore s = new Semaphore(1); public void deposit(int amount) { try { s.acquire(); } catch (InterruptedException e) { //handle interruption } balance += amount; s.release(); } Kein synchronized !

1. SEMAPHORES 3. Semaphores und Monitors

Semaphores = Monitor Semaphores sind äquivalent zu Monitors. Was genau bedeuted das ? Mit Monitors kann man Semaphores implementieren Mit Semaphores kann man Monitors implementieren

Umsetzung von Semaphores  Eclipse ( give me a second …)

Semaphores und Fairness Fairness : Jeder Thread der acquire () aufgerufen hat, kann irgendwann fortfahren ( “eventually” ) Einfache Lösung : FIFO - Queue  Performance nicht optimal

Semaphores anstelle von Monitors public class Buffer { Semaphore lock = new Semaphore(1); //init. free Semaphore cond = new Semaphore(0); //init. closed //… }

2. READER-WRITER-LOCK

Ein ReaderWriterLock Ähnliches Konstrukt wie Semaphore Beobachtung : Solange Threads nur lesen, können sie dies ruhig gleichzeitig tun. Idee : Lesen und Schreiben abwechselnd.  Eine Anzahl Reader - Slots ( wie bei Semaphore )  Ein einziger Writer - Slot  Entweder Reader - Slots besetzt, oder Writer - Slot besetzt

Verwendungsbeispiel class ConcurrentArray { ReaderWriterLock lock = new ReaderWriterLock(numReaders); int[] array; public int get(int i) { lock.acquireRead(); int r = array[i]; lock.releaseRead(); return r } public int set(int i, int v) { lock.acquireWrite(); array[i] = v; lock.release.Writer(); }

Bedingungen Effizient : Wenn Reader - Slots frei sind, sollten neue Reader zugelassen werden Liveness : Jeder Reader / Writer muss irgendwann an die Reihe kommen Fairness : Reader in Reader - Reihenfolge ; Writer in Writer - Reihenfolge Thread nur anhalten wenn unbedingt nötig

Wie Überprüfen? Thread 0 request read Thread 1 request read Thread 0 acquire read Thread 2 request read Thread 1 acquire read Thread 1 release read Thread 1 request write Thread 0 release read Thread 1 acquire write Thread 0 request read Thread 1 release write Thread 2 acquire read Thread 0 acquire read //etc. Nur lesen Nur scheiben Nur lesen

FRAGEN?