4 auf 1 - Betriebssysteme und verteilte Systeme

Wiederholung 

➥ Prozeßinteraktion 

➥ Synchronisation, Kommunikation 

➥ Wechselseitiger Ausschluß 

➥ nur jeweils ein Prozeß darf im kritischen Abschnitt sein 

➥ kritischer Abschnitt: Zugriff auf gemeinsame Ressourcen 

➥ Lösungsansätze: 

Betriebssysteme I 

WS 2004/2005 

16.11.04 

Roland Wismüller, Univ. Siegen 

roland.wismueller@uni-siegen.de 

Tel.: 0271/740-4050, Büro: H-B 8404 

c○2004, Roland Wismüller 05-1 

➥ Sperren der Interrupts (nur im BS, Einprozessorsysteme) 

➥ Sperrvariable: Peterson-Algorithmus 

➥ mit Hardware-Unterstützung: Read-Modify-Write 

➥ Nachteil: Aktives Warten (Effizienz, Verklemmungsgefahr) 


Wiederholung ... 

➥ Semaphore: Zähler und Prozeßwarteschlange 

➥ P(): herunterzählen, ggf. blockieren 

➥ V(): hochzählen, ggf. blockierten Prozeß wecken 

➥ Atomare Operationen (im BS realisiert) 

➥ Wechselseitiger Ausschluß mit Semaphoren: 

Prozeß 0 Prozeß 1 

P(Mutex); P(Mutex); 

// kritischer Abschnitt // kritischer Abschnitt 

V(Mutex); V(Mutex); 

➥ Semaphore auch für allgemeinere Synchronisation nutzbar 

➥ Beispiel: Erzeuger/Verbraucher-Problem 


Betriebssysteme I 

WS 2004/2005 

3 Prozeßinteraktion 

3.1 Synchronisation 

c○2004, Roland Wismüller 05-4

3.1 Synchronisation 

Heute: 

➥ Klassische Synchronisationsprobleme 

➥ Leser/Schreiber-Problem 

➥ Problem des schlafenden Friseurs 

➥ Monitore 

➥ Synchronisation mit PThreads 

➥ Barrieren 

➥ Tanenbaum 2.4.2, 2.4.3, 2.3.7 

➥ Stallings 5.4.4, 5.5 


3.1.5 Klassische Synchronisationsprobleme 

Das Leser/Schreiber-Problem 

➥ Gemeinsamer Datenbereich mehrerer Prozesse 

➥ Zwei Klassen von Prozessen (bzw. Zugriffen) 

➥ Leser (Reader) 

➥ dürfen gleichzeitig mit anderen Lesern zugreifen 

➥ Schreiber (Writer) 

➥ stehen unter wechselseitigem Ausschluß, 

auch mit Lesern 

➥ verhindert Lesen von inkonsistenten Daten 

➥ Typisches Problem in Datenbank-Systemen 


3.1.5 Klassische Synchronisationsprobleme ... 

Realisierung des Leser-Schreiber-Problems 

Leser 

while (true) { 

} 

P(mutex); 

rc++; 

if (rc == 1) 

P(db); 

V(mutex); 

readDataBase(); 

P(mutex); 

rc−−; 

if (rc == 0) 

V(db); 

V(mutex); 

UseData(); 


Eigenschaft der skizzierten Lösung 

➥ Die Synchronisation ist unfair: 

Leser haben Priorität vor Schreibern 

➥ Schreiber kann verhungern 

Leser 1 

Leser 2 

➥ Mögliche Lösung: 

rc=1 rc=1 rc=2 

Semaphore und 

gemeinsame Variable 

int rc=0; // Anzahl Leser 

Semaphor db; // Schützt Datenbank 

Semaphor mutex; 

Schreiber 

while(true) { 

CreateData(); 

P(db); 

writeDataBase(); 

V(db); 

} 


rc=1 

rc=2 

rc=2 rc=1 rc=2 rc=1 

➥ neue Leser blockieren, wenn ein Schreiber wartet 


...


Das Problem des schlafenden Friseurs 

➥ Friseursalon: 


Lösung für das Problem des schlafenden Friseurs 

int waiting = 0; 

Semaphor mutex = 1; 

Semaphor customers = 0; 

Semaphor barbers = 0; 

Kunde 

➥ ein Friseur, ein Friseurstuhl, N Stühle zum Warten 

➥ Falls kein Kunde zu bedienen: Friseur schläft 

➥ Kunde muß Friseur ggf. wecken 

➥ Falls Friseur schon einen Kunden bedient: 

➥ weitere Kunden setzen sich, falls Stuhl frei 

➥ falls kein Stuhl frei: Laden verlassen 

➥ Gesucht: Synchronisation ohne Race Conditions 


Gemeinsame Variable und Semaphore 

P(mutex) 

if (waiting < N) { 

waiting++; 

V(customers); 

V(mutex); 

P(barbers); 

getHaircut(); 

} else { 

V(mutex); 

} 

Anzahl wartender Kunden 

für wechselseitigen Ausschluß 

Anzahl wartender Kunden 

Anzahl wartender Friseure 

Friseur 

while (true) { 

P(customers); 

P(mutex); 

waiting−−; 

V(barbers); 

V(mutex); 

cutHair(); 

} 


3.1.6 Monitore 

Motivation 

➥ Programmierung mit Semaphoren ist schwierig 

➥ Reihenfolge der P/V-Operationen: Verklemmungsgefahr 

➥ Synchronisation über gesamtes Programm verteilt 

Monitor (Hoare, 1974; Brinch Hansen 1975) 

➥ Modul mit Daten, Prozeduren und Initialisierungscode 

➥ Zugriff auf die Daten nur über Monitor-Prozeduren 

➥ (entspricht in etwa einer Klasse) 

➥ Alle Prozeduren stehen unter wechselseitigem Ausschluß 

➥ nur jeweils ein Prozeß kann Monitor benutzen 

➥ Programmiersprachkonstrukt: Realisierung durch Übersetzer 


3.1.6 Monitore ... 

Bedingungsvariable (Zustandsvariable, condition variables) 

➥ Zur weiteren Synchronisation zwischen Monitor-Prozeduren 

➥ für anwendungsspezifische Bedingungen 

➥ z.B. voller Puffer im Erzeuger/Verbraucher-Problem 

➥ Bedingungsvariable verwaltet Warteschlange blockierter 

Prozesse 

➥ Zwei Operationen: 

➥ wait(): Blockieren des aufrufenden Prozesses 

➥ signal(): Aufwecken blockierter Prozesse 

➥ Bedingungsvariable hat ” kein Gedächtnis“: 

➥ signal() weckt nur einen Prozeß, der wait() bereits 

aufgerufen hat 



Funktion von wait(): 

➥ Aufrufender Prozeß wird blockiert 

➥ nach Ende der Blockierung kehrt wait() zurück 

➥ Aufrufender Prozeß wird in Warteschlange der Bedingungsvariable 

eingetragen 

➥ Monitor steht bis zum Ende der Blockierung anderen 

Prozessen zur Verfügung 

Funktion von signal(): 

➥ Falls Warteschlange der Bedingungsvariable nicht leer: 

➥ mindestens einen Prozeß wecken: 

aus Warteschlange entfernen und Blockierung aufheben 



Varianten für signal(): 

1. Ein Prozeß wird geweckt (meist der am längsten wartende) 

(a) signalisierender Prozeß bleibt im Besitz des Monitors 

(b) geweckter Prozeß erhält den Monitor sofort 

i. signalisierender Prozeß muß sich erneut bewerben 

(Hoare) 

ii. signal() muß letzte Anweisung in Monitorprozedur 

sein (Brinch Hansen) 

2. Alle Prozesse werden geweckt 

➥ signalisierender Prozeß bleibt im Besitz des Monitors 

➥ Bei 1a) und 2) ist nach Rückkehr aus wait() nicht sicher, 

daß die Bedingung (noch) erfüllt ist! 



Typische Verwendung von wait() und signal() 

➥ Testen einer Bedingung 

➥ bei Varianten 1b): 

➥ if (!Bedingung) wait(condVar); 

➥ bei Varianten 1a) und 2): 

➥ while (!Bedingung) wait(condVar); 

➥ Signalisieren der Bedingung 

➥ if (Bedingung hergestellt) signal(condVar); 



Aufbau eines Monitors nach Hoare 

eintretende Prozesse 

Wartebereich 

Bedingung c1 

wait(c1) 

Bedingung cn 

wait(cn) 

signal(...) 

Monitor 

Lokale Daten 

Bedingungsvariablen 

Prozedur 1 

... 

Prozedur k 

Initialisierungscode 

Ausgang 

Eingang 



Semaphor-Realisierung m. Monitor (Pascal-artig, Brinch Hansen) 

monitor Semaphor 

condition nonbusy; 

integer count; 

procedure P 

begin 

count := count - 1; 

if count < 0 then 

wait(nonbusy); 

end; 


Erzeuger/Verbraucher m. Monitor (Pascal-artig, Brinch Hansen) 

monitor ErzeugerVerbraucher 

condition full, empty; 

integer count; 

procedure Insert(item: integer) 

begin 

if count = N then 

wait(full); 

insert item(item); 

count := count + 1; 

if count = 1 then 

signal(empty); 

end; 

procedure V 

begin 

count := count + 1; 

if count N do 

wait(full); 

... 

➥ Nachteil: viele Threads konkurrieren um Wiedereintritt in den 

Monitor 



Java bietet Monitor-ähnliche Sprachkonzepte an 

➥ Klassenkonzept statt Modulkonzept 

➥ Synchronisierte Methoden (synchronized) 

➥ stehen (pro Objekt!) unter wechselseitigem Ausschluß 

➥ Basisklasse Object definiert Methoden wait(), notify() und 

notifyAll() 

➥ alle Klassen erben diese Methoden 

➥ keine expliziten Bedingungsvariablen 

➥ nur eine implizite Bedingungsvariable pro Objekt 


3.1.7 Synchronisation mit PThreads 

Mutex-Variable für wechselseitigen Ausschluß 

➥ Verhalten wie binäres Semaphor 

➥ Zustände: gesperrt, frei 

➥ Deklaration und Initialisierung (Initialzustand: frei): 

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 

➥ Operationen: 

➥ Sperren: pthread_mutex_lock(&mutex) 

➥ Freigeben: pthread_mutex_unlock(&mutex) 

➥ Sperrversuch: pthread_mutex_trylock(&mutex) 

➥ blockiert nicht, liefert ggf. Fehlercode 


3.1.7 Synchronisation mit PThreads ... 

Bedingungsvariablen 

➥ Deklaration und Initialisierung: 

pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 

➥ Operationen: 

➥ Warten: pthread_cond_wait(&cond, &mutex) 

➥ Thread wird blockiert, mutex wird freigegeben 

➥ Nach Signalisierung: pthread_cond_wait kehrt erst 

zurück, wenn mutex wieder erfolgreich gesperrt ist 

➥ Signalisieren: 

➥ ein Thread: pthread_cond_signal(&cond) 

➥ alle Threads: pthread_cond_broadcast(&cond) 

➥ entspricht Varianten 1a) und 2) bei Monitor 



Bedingungsvariablen ... 

➥ Herstellen der signalisierten Bedingung und Signalisierung 

muß bei gesperrtem Mutex erfolgen! 

➥ Sonst: Gefahr des lost wakeup 

pthread_mutex_lock(&mx); 

condition = true; 

pthread_cond_signal(&cv); 

pthread_mutex_unlock(&mx); 


Nachbildung eines Monitors mit PThreads: 

Erzeuger/Verbraucher-Problem 

Globale Variablen 

pthread_mutex_lock(&mx); 

... 

while (!condition) 

pthread_cond_wait(&cv,&mx); 

... 

pthread_mutex_unlock(&mx); 


static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 

static pthread_cond_t full = PTHREAD_COND_INITIALIZER; 

static pthread_cond_t empty = PTHREAD_COND_INITIALIZER; 

static int count = 0; 



Einfügefunktion 

void Insert(int item) 

{ 

pthread_mutex_lock(&mutex); 

while (count == N) 

pthread_cond_wait(&full, &mutex); 

insert_item(item); 

count++; 

if (count == 1) 

pthread_cond_signal(&empty); 

pthread_mutex_unlock(&mutex); 

} 



Entfernfunktion 

int Remove() 

{ 

int result; 

pthread_mutex_lock(&mutex); 

while (count == 0) 

pthread_cond_wait(&empty, &mutex); 

result = remove_item(); 

count--; 

if (count == N-1) 

pthread_cond_signal(&full); 

pthread_mutex_unlock(&mutex); 

return result; 

} 



Erzeuger und Verbraucher mit PThreads 

void *Producer(void *arg) void *Consumer(void *arg) 

{ { 

int item = 0; int item; 

int i; int i; 

for (i=0; i

3.1.8 Barrieren 

➥ Synchronisationsmechanismus für Gruppen von Prozessen 

bzw. Threads 

➥ Semantik: 

➥ Prozeß, der Barriere erreicht, wird blockiert, 

bis auch alle anderen Prozesse die Barriere erreicht haben 

Aufruf der Barrieren−Operation Operation kehrt zurück 

Prozeß A 

Prozeß B 

Prozeß B 

Prozeß blockiert 

Barriere 

Zeit 

➥ Erlaubt Strukturierung nebenläufiger Anwendungen in 

synchrone Phasen

4 auf 1 - Betriebssysteme und verteilte Systeme

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?