JJ Prozesse und Nebenläufigkeit

Transkript

1 1 Wiederholung: Algorithmus von Peterson boolean ready0=false, ready1=false; int turn=0; JJ Prozesse und Nebenläufigkeit (Auszug aus der Vorlesung) while( 1 ) Prozess 0 ready0 = true; turn = 1; while( ready1 && turn == 1 ); /* critical sec. */ ready0 = false; /* uncritical */ while( 1 ) Prozess 1 ready1 = true; turn = 0; while( ready0 && turn == 0 ); /* critical sec. */ ready1 = false; /* uncritical */ Aktives Warten Spinlock Verbrauch von Rechenzeit ohne Nutzen, Behinderung nützlicher Prozesse Für verdrängende Strategien, schlechte Effizienz bei langen Zeitscheiben JJ.1 Effizient für kurze kritische Abschnitte Heute fast ausschließlich in Multiprozessorsystemen eingesetzt JJ.2 2 Spezielle Maschinenbefehle Spezielle Maschinenbefehle können die Programmierung kritischer Abschnitte unterstützen und vereinfachen Test-and-set (TAS) Atomare Ausführung mit folgender Wirkung (Java-ähnliche Syntax) Swap boolean test_and_set( MemoryBit lock ) boolean tmp = lock.getbit(); lock.setbit(true); return tmp; Bit wird gesetzt; vorheriger Wert wird zurückgegeben Atomares Vertauschen zweier Worte JJ.3 2 Spezielle Maschinenbefehle (2) Kritische Abschnitte mit Test-and-Set Befehlen MemoryBit lock = new MemoryBit(false); Prozess 0 while( 1 ) while( test_and_set(lock) ); /* critical sec. */ lock.setbit(false); /* uncritical */ Code ist identisch und für mehr als zwei Prozesse geeignet Implementierung mit Swap analog Prozess 1 while( 1 ) while( test_and_set(lock) ); /* critical sec. */ lock.setbit(false); /* uncritical */ 0 durch 1 tauschen sperrt spinning auf 1 0 setzen gibt wieder frei JJ.4

2 3 Semaphor 3 Semaphor (2) Ein Semaphor (griech. Zeichenträger) ist eine Datenstruktur des Systems mit zwei Operationen (nach Dijkstra) P-Operation (proberen; passeren; wait; down) wartet bis Zugang frei V-Operation (verhogen; vrijgeven; signal; up) macht Zugang für anderen Prozess frei Datenstruktur für Zugangssteuerung: Integer-Wert class Semaphore int s; Semaphore( int init ) s = init; void P() while ( s<=0 ); s--; void V() s++; P und V müssen atomar ausgeführt werden! JJ.5 Implementierung kritischer Abschnitte mit einem Semaphor Semaphore lock = new Semaphore( 1 ); while( 1 ) /* critical sec. */ Prozess 0 /* uncritical */ while( 1 ) /* critical sec. */ /* uncritical */ Implementierung von P und V meist als Betriebssystem-Resource Einbeziehen des Schedulers in die Semaphor-Operationen möglich kein aktives Warten: Ausnutzen der Blockierzeit durch andere Prozesse Prozess 1 JJ.6 3 Semaphor (3) Abstrakte Beschreibung von Semaphoren (PV System) für jede Operation wird eine Bedingung angegeben falls Bedingung nicht erfüllt, wird die Operation blockiert für den Fall, dass die Bedingung erfüllt wird, wird eine Anweisung definiert, die ausgeführt wird Beispiel: zählende Semaphore P( S ) S > 0 S := S 1 V( S ) TRUE S := S Klassische Koordinierungsprobleme Gegenseitiger Ausschluss (Mutual Exclusion) nur ein Prozess darf bestimmte Anweisungen ausführen Puffer fester Größe (Bounded Buffers) Blockieren der lesenden und schreibenden Prozesse, falls Puffer leer oder voll Leser-Schreiber-Problem (Reader-Writer Problem) Leser können nebenläufig arbeiten; Schreiber darf nur alleine zugreifen Varianten: Leser oder Schreiber bevorzugt Philosophenproblem (Dining-Philosophers) im Kreis sitzende Philosophen benötigen das Besteck der Nachbarn zum Essen JJ.7 JJ.8

3 4.1 Gegenseitiger Ausschluss Eigentlich reicht Semaphor mit zwei Zuständen Zählende Semaphore mit 1 initialisiert Alternativ mit Boole scher-variable: P() setzt true V() setzt false Abstrakte Beschreibung: binäre Semaphore P( S ) S 0 S := 0 V( S ) TRUE S := 1 JJ Bounded Buffers Puffer fester Größe mehrere Prozesse lesen/leeren und beschreiben/füllen den Puffer Erzeuger-Verbraucher-Szenarien, z.b. bei UNIX-Pipes Problem: Koordinierung von Leser und Schreiber gegenseitiger Ausschluss beim Pufferzugriff Blockierung des Lesers bei leerem, des Schreibers bei vollem Puffer Implementierung mit zählenden Semaphoren zwei Funktionen put/get zum Zugriff auf den Puffer Puffer wird durch ein Feld implementiert, das als Ringpuffer wirkt Integer-Variablen für Feldindizes auf Anfang und Ende des Ringpuffers ein Semaphor für den gegenseitigen Ausschluss je einen Semaphor für das Blockieren bei Puffer voll und Puffer leer Semaphor full zählt wieviele Zeichen noch in den Puffer passen Semaphor empty zählt wieviele Zeichen im Puffer sind JJ Bounded Buffers (2) char[] buffer = new char[n]; int inslot = 0, outslot = 0; Semaphore mutex = new Semaphore(1), empty = new Semaphore(0), full = new Semaphore(N); void put( char c ) full.p(); mutex.p(); buffer[inslot] = c; inslot = (inslot+1)%n; mutex.v(); empty.v(); char get() char c; empty.p(); mutex.p(); c = buffer[outslot]; outslot = (outslot+1)%n; mutex.v(); full.v(); return c; 4.3 Leser-Schreiber-Probleme Lesende und schreibende Prozesse ähnlich wie gegenseitiger Ausschluss Leser können nebenläufig zugreifen (Leser ändern keine Daten) Schreiber können nur exklusiv zugreifen (Daten sonst inkonsistent) Zwei Varianten (nach Courtois et al. 1971) Erstes Leser-Schreiber-Problem Kein Leser soll warten müssen, es sei denn ein Schreiber ist gerade aktiv Zweites Leser-Schreiber-Problem Schreiboperationen sollen so schnell wie möglich durchgeführt werden Beide realisierbar mit diversen Semaphoren und Zählvariablen Komplexe Implementierungen Nutzen spezieller Semaphor-Typen JJ.11 JJ.12

4 4.3 Leser-Schreiber-Probleme (2) PV-Chunk-Semaphore für erstes LSP 2. Parameter gibt Anzahl der atomar auszuführenden P- oder V-Operationen an Abstrakte Beschreibung P( S, k ) S k S := S k V( S, k ) TRUE S := S + k Implementierung mit PV-Chunk für maximal N Leser PVChunkSemaphore mutex = new PVChunkSemaphore( N ); mutex.p( 1 ); Leser mutex.p( N ); Schreiber /* reading */ /* writing */ mutex.v( 1 ); mutex.v( N ); JJ Leser-Schreiber-Probleme (3) Up-Down Semaphore für zweites LSP zwei Operationen up und down, die den Semaphor hoch- und runterzählen Nichtblockierungsbedingung für up/down über einer Semaphoren-Menge Abstrakte Beschreibung für Up-down Semaphore up( S, S i ) S 0 i S := S + 1 i down( S, S i ) S 0 i i S := S 1 JJ Leser-Schreiber-Probleme (4) 4.4 Philosophenproblem Implementierung mit Up-Down Semaphoren: UpDownSemaphore s = new UpDownSemaphore( new int[3]0,0,0 ); final int reader = 0, writer = 1, mutexw = 2; Leser s.down( reader, new int[1]writer ); /* reading */ s.up( reader, null ); Schreiber s.down( writer, null ); s.down( mutexw, new int[2]mutexw,reader ); /* writing */ s.up( mutexw, null ); s.up( writer, null ); negative Zähler für Leser (reader) und anstehende Schreiber (writer) sowie Semaphor für gegens. Ausschluss der Schreiber (mutexw) JJ.15 Fünf Philosophen am runden Tisch Problem Gleichzeitiges Belegen mehrerer Betriebsmittel (hier Gabeln) Verklemmung: alle nehmen die Gabel der gleichen Seite zuerst Aushungerung: einige kommen nie zu beiden Gabeln Lösung 1: einer der Philosophen muss zuerst die andere Gabel nehmen System verklemmt sich nicht mehr Philosophen denken oder essen "The life of a philosopher consists of an alternation of thinking and eating." (Dijkstra, 1971) zum Essen benötigen sie zwei Gabeln, die jeweils zwischen zwei benachbarten Philosophen abgelegt sind JJ.16

5 4.4 Philosophenproblem (2) Lösung 2: gleichzeitiges Aufnehmen der Gabeln Implementierung mit binären oder zählenden Semaphoren ist nicht trivial Unübersichtliche Lösung mit Zusatzvariablen PV-multiple Semaphore gleichzeitiges und atomares Belegen mehrerer Semaphoren Abstrakte Beschreibung: 4.4 Philosophenproblem (3) Implementierung mit PV-multiple Semaphoren Schnittstelle ähnlich Up-Down-Semaphore-Implementierung PVMultSemaphore forks = new PVMultSemaphore( 5, new int[5] 1,1,1,1,1 ); while( 1 ) /* think */ Philosoph i, i [ 0, 4] P( S i ) i, S i > 0 i, S i = S i 1 forks.p( new int[2]i, (i+1)%5 ); V( S i ) TRUE i, S i = S i + 1 /* eat */ forks.v( new int[2]i, (i+1)%5 ); JJ.17 JJ.18 5 Monitore 5 Monitore (2) Problem der Klammerung kritischer Abschnitte Programmierer müssen Konvention der Klammerung einhalten Koordinierungsfehler bei falscher Klammerung sind fatal /* critical sec. */ /* critical sec. */ Automatische Klammerung wünschenswert Beispiel: Java führt zu Verklemmung (Deadlock) führt zu unerwünschter Nebenläufigkeit Monitor als einfaches Konzept zur Koordinierung (B. Hansen/Hoare 1975) programmiersprachliches Konstrukt private Variablen Prozeduren laufen immer im gegenseitigen Ausschluss immer korrekte P-V Reihung, da implizit u.a. an Prozedurgrenzen Condition-Variables zum Blockieren Aufruf von wait(c) führt zur Blockade an Condition-Variable c Aufruf von signal(c) führt zur Deblockade eines Prozesses, der an Condition-Variable c blockiert ist Blockieren und Deblockieren unter gegenseitigem Ausschluss Freigabe der Monitor-Sperre bei Blockieren Belegen der Monitor-Sperre vor Deblockierung synchronized( lock ) /* critical sec. */ JJ.19 JJ.20

6 5.1 Beispiel: Erzeuger-Verbraucher monitor char buffer[n]; int inslot = 0, outslot = 0, count = 0; condition notfull, notempty; void put( char c ) while( count == N ) wait( notfull ); buffer[inslot] = c; inslot = (inslot+1)%n; count++; signal( notempty ); char get( void ) char c; while( count == 0 ) wait( notempty ); c = buffer[outslot]; outslot = (outslot+1)%n; count--; signal( notfull ); return c; 5.2 Beispiel: Java Jedes Java-Objekt kann Monitor darstellen Methoden des Monitors werden als synchronized markiert Objekt selbst stellt implizite Condition-Variable dar ( this ) wait und notify statt wait und signal notifyall deblockiert alle am Objekt blockierten Threads während wait-phase wird Alternative explizite kritische Abschnitte im Code synchronized( obj ) beliebige Objekte obj als Condition Variables wait/notify als Methoden an obj auszuführen weiteres siehe Java-Dokumentation JJ.21 JJ Beispiel: Java (2) 5.2 Beispiel: Java (3) class buffer char buffer[] = new char[n]; int inslot = 0, outslot = 0, count = 0; synchronized public void put( char c ) while( count == N ) try wait(); catch( ) buffer[inslot] = c; inslot =(inslot+1)%n; count++; notifyall(); synchronized public char get( void ) char c; (im catch-block wird InterruptedException behandelt) while( count == 0 ) try wait(); catch( ) c = buffer[outslot]; outslot = (outslot+1)%n; count--; notifyall(); return c; JJ.23 Threaderzeugung class MyThread extends Thread public void run() /* thread code */ Thread t = new MyThread(); t.start(); Thread muss mit start() und nicht mit run() gestartet werden! gemeinsame Variablen ggf. mit volatile markieren weitere Möglichkeiten ohne Vererbung (siehe Java-Dokumentation) JJ.24