2 NebenlÃ¤ufigkeit, Threads und Synchronisation

(107) 

2 Nebenläufigkeit, Threads und Synchronisation 

Gliederung: 

• Parallele Prozesse 

• Java-Threads 

• Synchronisation, gegenseitiger Ausschluß 

• Das Monitorkonzept 

• Deadlocks 

2.1 Parallele Prozesse 

Prozess: Ausführung eines sequentiellen Programmstückes in dem zugeordneten Speicher 

(Adressraum). Veränderlicher Zustand: Speicherinhalt und Programmposition. 

Parallele Prozesse: mehrere Prozesse, die gleichzeitig auf mehreren Prozessoren ausgeführt 

werden. 

©2007 Prof. Dr. Gerd Szwillus 

Vorlesung „Grundlagen der Programmierung 2“, SS 2007, Gerd Szwillus 

(108) 

Verzahnte Ausführung kann parallele Ausführung simulieren. Häufiger Wechsel vermittelt den 

Eindruck, dass alle Prozesse gleichmäßig fortschreiten. 

Nebenläufige Prozesse: Prozesse, die parallel oder verzahnt ausgeführt werden können. 

Threads („Fäden“ der Programmausführung): Prozesse, die parallel oder verzahnt in 

gemeinsamem Speicher ablaufen. Die Prozessumschaltung ist besonders einfach und schnell. 


Vorlesung „Grundlagen der Programmierung 2“, SS 2007, Gerd Szwillus

(109) 

Anwendungen paralleler Prozesse: 

• Benutzungsoberflächen: 

Die Ereignisse werden von einem speziellen Systemprozess weitergegeben. Aufwendige 

Berechnungen sollten nebenläufig programmiert werden, damit die Bedienung der Oberfläche 

nicht blockiert wird. 

• Simulation realer Abläufe: 

z. B. Produktion in einer Fabrik 

• Animation: 

Veranschaulichung von Abläufen, Algorithmen; Spiele 

• Steuerung von Geräten: 

Prozesse im Rechner überwachen und steuern externe Geräte, z. B. Montage-Roboter 

• Leistungssteigerung durch Parallelrechner: 

mehrere Prozesse bearbeiten gemeinsam die gleiche Aufgabe, z. B. paralleles Sortieren großer 

Datenmengen. 



(110) 

2.2 Java-Threads 

Begriff „Threads“: Prozesse, die nebenläufig, gemeinsam im Speicher des Programms ablaufen. 

Zwei Techniken zur Thread-Erzeugung: 

1. Nutzung des Interface Runnable 

2. Erben von der Thread-Klasse 

Erste Technik: 

Eine Benutzerklasse B implementiert das Interface Runnable 

verlangt das Vorhandensein einer Methode run() 

Erzeugung eines Threads t mit einer Instanz von B als Parameter 

Starten des Threads mit t.start(); 



(111) 

a) Eine Benutzerklasse implementiert das Interface Runnable: 

class Aufgabe implements Runnable { 

... 

public void run () { 

// vom Interface geforderte Methode run 

... // das als Prozess auszuführende Programmstück 

} 

Aufgabe (...) {...} 

// Konstruktor 

} 

b) Der eigentliche Prozess wird als Objekt der vordefinierten Klasse Thread erzeugt: 

Thread auftrag = new Thread (new Aufgabe (...)); 

c) Erst folgender Aufruf startet dann den Prozess: 

auftrag.start(); //Der neue Prozess beginnt, neben dem hier aktiven zu laufen. 



Einfaches Beispiel: 

Einem Prozess übergibt man eine ganze Zahl n, dieser druckt n-mal diese Zahl aus und 

hört dann auf. 

class T implements Runnable { 

private String name; 

private int anzahl; 

public void run() { 

System.out.print("Thread "+name+" fängt an / "); 

for (int i=0; i

(113) 

Im Hauptprogramm werden vier Threads aus den „Runnable“-Objekten vom Typ T mit 

verschiedenen Parametern erzeugt und gestartet: 

class TTest1 { 

public static void main (String [] args) { 

Thread t1 = new Thread(new T("1", 10)); 




t1.start(); t2.start(); t3.start(); t4.start(); 

} 

} 

Ergebnis (ein mögliches – jeder Programmlauf zeigt eine andere zufällige Reihenfolge): 

Thread 3 fängt an / 3333 Thread 4 fängt an / 4 Thread 1 fängt an / Thread 2 

fängt an / 221 / Thread 3 hört auf / Thread 4 hört auf / Thread 2 hört auf / 

111111111 / Thread 1 hört auf / 

[3 3 3 3 3 [4 4 [1 [2 2 2 1 3] 4] 2] 1 1 1 1 1 1 1 1 1 1] 

1: [ + + + + + + + + + + ] 

2: [ + + ] 

3: [ + + + + ] 

4: [ + ] 



Zweite Technik: 

Eine Klasse B wird als Unterklasse der vordefinierten Klasse Thread definiert 

Überschreiben der Methode run() 

Starten einer Instanz t des Threads mit Aufruf der geerbten Methode t.start(); 

a) Die Benutzerklasse wird als Unterklasse der vordefinierten Klasse Thread definiert: 

class T extends Thread { 

... 

public void run () { 

//überschreibt die Thread-Methode run() 

... 

} //das als Prozess auszuführende Programmstück 

(114) 

} 

T (...) {...} 

// Konstruktor 

b) Der Prozess wird als Objekt der Benutzerklasse erzeugt (es ist auch ein Thread-Objekt): 

Thread t = new T (...); 

c) Erst folgender Aufruf startet dann den Prozess: 

t.start(); 

//der neue Prozess beginnt neben dem hier aktiven zu laufen 



(115) 

Einfaches Beispiel nochmal: 

class T extends Thread { ... } 

// Alles andere genau wie vorher! 

Im Hauptprogramm werden vier T-Objekte direkt als Thread eingesetzt: 

class TTest2 { 

public static void main (String [] args) { 

Thread t1 = new T("1", 10); 

Thread t2 = new T("2", 2); 



t1.start(); t2.start(); t3.start(); t4.start(); 

} 

} 

TTest2.java 



Gegenüberstellung 

(116) 

class T implements Runnable { 

... 


// Prozess 

} 

... 

} 

Innerhalb der Klasse T stehen die Methoden 

von Thread nicht unmittelbar zur Verfügung 


... 


// Prozess 

} 

... 

} 

Innerhalb der Klasse T stehen die Methoden 

von Thread zur Verfügung 

Thread t = new Thread(new T(...)); Thread t = new T(...); 

t.start(); 

t.start(); 

• Klasse Thread verwaltet die Ausführung der run-Methode im Zusammenspiel mit allen 

anderen Prozessen 

• Methode zum Ändern des dynamischen Zustands des Prozesses 

• Prioritäten, gegenseitigen Ausschluss, Signalisieren von Bedingungen, Exceptions 



(117) 

• Unterliegendes Zustandsmodell für Threads: 

o runnable: Prozess läuft 

o waiting: Prozess wartet auf einen anderen Prozess (Bedingung) 

o timed waiting: Prozess wartet für eine bestimmte Zeit 

o terminated: Prozess ist 

abgeschlossen 

new 

Programm startet den Thread 

Weitermachenl 

runnable 

Thread ist fertig 

terminated 

Warten 

Schlafen legen 

Zeitintervall 

abgelaufen 

waiting 

timed 

waiting 



Zweites Beispiel: Eine Digitaluhr 

Eigenschaft: Aktualisieren der Anzeige alle 1000ms 

• Kurzfristig anhalten mit STOP 

• Weiterlaufenlassen mit GO 

• Ganz beenden mit dem Schliesse-Button 

Steuerung der Uhr mit der Variablen running: 

boolean running == true genau dann, wenn die Uhr "läuft" 

= Anzeige wechselt jede Sekunde 

Grundstruktur des Programms mit den zwei Klassen 

TDigiClock der Thread, der die Änderungen des anzuzeigenden Strings berechnet 

DigiClock der anzeigende JFrame, gleichzeitig Hauptklasse 

(118) 

DigiClock.java 



(119) 

Thread TDigiClock, der die Anzeige setzt 

class TDigiClock implements Runnable { 

private boolean running; 

DigiClock jfDigiClock; 

// Referenz auf den JFrame, der die Uhr anzeigt 

public TDigiClock (DigiClock jfDigiClock) { 

this.jfDigiClock = jfDigiClock; } 


running = true; 

while (running) { 

jfDigiClock.setAnzeige 

new Date().toString().substring(11,19)); 

try { Thread.sleep(1000); } 

catch (InterruptedException ex) { } 

} 

} 

} 

public void endIt() { running = false; } 



Die Hauptklasse (Fenster, Buttons, Anzeige): 

class DigiClock extends JFrame implements ActionListener 

{ JLabel anzeige = new JLabel(" "); 

JButton stop = new JButton ("STOP!"); 

JButton go = new JButton ("GO"); 

JPanel buttons = new JPanel(); 

// Initialisierungen im Konstruktor 

TDigiClock clock = new TDigiClock(this); // Anlegen eines Uhr-Threads 

void setAnzeige(String s) { anzeige.setText(s); } 

// Methode zum Setzen der Anzeige, aufgerufen vom DigiClock-Thread 

public void actionPerformed (ActionEvent e) { // Button-Funktionen 

if (e.getActionCommand().equals("go")) { 

go.setEnabled(false); 

stop.setEnabled(true); 

new Thread(clock).start(); // Starten eines neuen Threads, der alle 

} // 1000ms die Anzeige setzt 

else { 

stop.setEnabled(false); 

go.setEnabled(true); 

clock.endIt(); 

// setzt running = false, Prozess endet 

} 

} 

(120) 



DigiClock() { 

// Konstruktor des JFrames 

getContentPane().setLayout(new BorderLayout()); 

anzeige.setHorizontalAlignment(JLabel.CENTER); 

anzeige.setFont(new Font("Times-Roman", Font.BOLD, 72)); 

getContentPane().add(anzeige, BorderLayout.NORTH); 

buttons.setLayout(new GridLayout(1,2)); 

stop.addActionListener(this); 

stop.setEnabled(true); 

buttons.add(stop); 

go.addActionListener(this); 

go.setEnabled(false); 

buttons.add(go); 

(121) 

} 

getContentPane().add(buttons, BorderLayout.SOUTH); 

... 

public static void main (String [] args) { // Triviales Hauptprogramm 

new TDigiClock(); 

} 



Wichtige Methoden der Klasse Thread: 

(122) 

public void run () 

public void start () 

public void join () 

throws InterruptedException 

public static void sleep 

(long millisec) 

throws InterruptedException 

wird überschrieben mit der Methode, die die 

auszuführenden Anweisungen enthält 

startet die Ausführung des Prozesses, nur einmal 

pro Thread möglich! 

der aufrufende Prozess wartet bis der angegebene 

Prozess terminiert ist: 

try { auftrag.join(); } 

catch (InterruptedException e){} 

der aufrufende Prozess wartet mindestens die in 

Millisekunden angegebene Zeit: 

try { Thread.sleep (1000); } 

catch (InterruptedException e){} 



(123) 

Drittes Beispiel: Prozesse warten auf andere 

Variante von TTest2 

• Drucken von Zeichen, dazwischen aber Übergang in den Schlafmodus für eine definierte 

"sleep time" 

• Übergabe eines anderen Threads, auf den mit dem Abschluss ggf. (!) gewartet wird 



private int anzahl, sleepTime; 

private Thread wartetAuf; 


System.out.println(" Thread "+name+" faengt an / "); 

for (int i=0; i

(125) 

2.3 Synchronisation, gegenseitiger Ausschluss, Monitorkonzept 

2.3.1 Synchronisation von Prozessen über gegenseitigen Ausschluss 

Wenn mehrere Prozesse die Werte gemeinsamer Variablen verändern, kann eine ungünstige 

Verzahnung (Parallelausführung) zu inkonsistenten Daten führen. 

Z. B. zwei Prozesse p und q benutzen lokale Variable tmp und eine gemeinsame Variable konto: 

Prozeß p tmp = konto; 

konto = tmp-300; 

Prozeß q tmp = konto; konto = tmp + 1000; 

p holt sich Kontostand 400 €, q auch, q schreibt 1400 €, p überschreibt mit 100 € - 1300 € futsch...! 



• Kritische Abschnitte: zusammengesetzte Operationen, die gemeinsame Variablen lesen 

und/oder verändern. 

Prozesse müssen kritische Abschnitte unter gegenseitigem Ausschluß ("mutual exclusion") 

ausführen: 

D. h. zu jedem Zeitpunkt darf höchstens ein Prozess solch einen kritischen Abschnitt für 

bestimmte Variablen ausführen. 

(126) 

Andere Prozesse, die für die gleichen Variablen mit der Ausführung eines kritischen Abschnitts 

beginnen wollen, müssen warten. 

Experiment: Ist es wirklich so schlimm? 

Java-Programm „SynchTest“ 

SynchTest.java 

• Zwei Prozesse, jeder führt 5 Buchungen durch, laufen nebenläufig ohne Kontrolle 

• Jeder Prozess hat eine individuelle Bearbeitungsdauer und Wartezeit zwischen je zwei 

Buchungen 



(127) 

class Ablauf extends Thread { 

private int tmp; 

private int betrag; 

private int zeitBedarf, zeitAbstand; 


Ablauf (String name, int zeitBedarf, int zeitAbstand, int betrag) 

{ ... } 


for (int i=0; i

(129) 

2.3.2 Das Monitorkonzept 

• Monitor 

Ein Modul, der Daten und die Operationen darauf kapselt. 

Die kritischen Abschnitte auf den Daten werden als Monitor-Operationen formuliert. 

Prozesse rufen Monitor-Operationen auf, um auf die Daten zuzugreifen. 

Die Monitor-Operationen werden unter gegenseitigem Ausschluss ausgeführt. 



• Monitore in Java: 

Anweisungsblöcke oder Methoden einer Klasse, die kritische Abschnitte auf Objektvariablen 

implementieren, können als synchronized gekennzeichnet werden: 

class Bank { 

synchronized public void kontoBewegung (...) {...} 

... 

private int[] konten; 

} 

Jedes Objekt der Klasse wirkt als Monitor für seine (!) Objektvariablen: 

Aufrufe von synchronized Methoden von mehreren Prozessen für dasselbe 

Objekt werden unter gegenseitigem Ausschluss ausgeführt. 

Zu jedem Zeitpunkt kann höchstens 1 Prozess mit synchronized Methoden auf 

Objektvariable zugreifen. 

(130) 



(131) 

Nochmal unser Experiment (erst ohne Monitor, dann mit Monitor): 

class Konto { 

private int stand = 0; 

// Eine Klasse für die Konten – jedes Konto ein Objekt 

} 

public void bewegung(String name, int betrag) // KRITISCHER ABSCHNITT 

{ 

int tmp; 

tmp = stand; 

System.out.println(name+": Gelesener Kontostand "+ tmp); 

tmp = tmp + betrag; 

System.out.println(name+": Geschriebener Kontostand "+ tmp); 

stand = tmp; 

} 

• Die Ablauf-Klasse beschreibt einen Prozess, der fünfmal das Gleiche bucht 

• Im Hauptprogramm wird ein Konto angelegt und zwei Abläufe werden darauf losgelassen 

• Wieder: Übergabe von Bearbeitungszeit und Wartezeit 

OhneMonitorTest.java 



(132) 

• Änderung: Schlüsselwort synchronized bei bewegung(...): 

synchronized public void bewegung(String name, int betrag) {...} 

• Methode kann nun von maximal einem Prozess zu einer Zeit ausgeführt werden! 

• Korrekter Ablauf, unabhängig von den Zeitangaben! 

MonitorTest.java 

Eigenschaft dieses Beispiels: 

• Sobald die "Ressource" Konto frei ist, kann jeder der beiden Ablauf-Objekte diese nutzen, 

es gibt keine Vorbedingung! 

• Daher reicht die Sicherstellung, dass kein doppelter Zugriff im kritischen Abschnitt passiert. 

• Das reicht aber nicht immer... 



(133) 

2.3.3 Monitore mit Bedingungssynchronisation 

• Bedingungssynchronisation: 

Ein Prozess wartet, bis eine Bedingung erfüllt ist - verursacht durch einen anderen Prozess; 

z. B. erst dann in einen Puffer schreiben, wenn darin Platz ist. 

• Bedingungssynchronisation im Monitor: 

Ein Prozess, der in einer kritischen Monitor-Operation auf eine Bedingung wartet, muss den 

Monitor freigeben, damit andere Prozesse den Zustand des Monitors ändern können. 

• Bedingungssynchronisation in Java: 

Vordefinierte Methoden der Klasse Object zur Bedingungssynchronisation: 

(Sie müssen aus synchronized Abschnitten heraus aufgerufen werden.) 

wait() blockiert den aufrufenden Prozess und gibt den Monitor frei - das 

Objekt, dessen synchronized Methode er gerade ausführt. 

notify() weckt einen der in diesem Monitor blockierten Prozesse; welcher ist 

nicht definiert. 

notifyAll() weckt alle in diesem Monitor blockierten Prozesse; sie können 

weiterlaufen, sobald der Monitor frei ist. 



• Grundstruktur: 

a) Anforderung 

Solange meine Anforderung nicht erfüllt: wait(); //Hier geht’s nur weiter, wenn 

//andere mich "benachrichtigen" 

Wenn Anforderung jetzt erfüllt: Ressourcen nutzen. 

Sonst: wieder warten! 

b) Rückgabe 

Ressourcen zurückgeben 

Allen Wartenden sagen, dass sie es jetzt wieder probieren können: notifyAll(); 

Wichtig bei a): 

Nachdem ein blockierter Prozess geweckt wurde, muss er die Bedingung, auf die er wartet, 

erneut prüfen - sie könnte schon durch schnellere Prozesse wieder ungültig sein: 

while (!erfüllt) try { wait(); } catch (InterruptedException e) {} 

(134) 



(135) 

Monitor zur Vergabe von Ressourcen („Betriebsmitteln“): 

Aufgabe: Eine begrenzte Anzahl gleichartiger Ressourcen wird von einem Monitor verwaltet. 

Prozesse fordern einige Ressourcen an und geben sie später zurück. 

Programmstruktur: 

• Eine Klasse Monitor - verwaltet die verfügbaren Ressourcen (zählen genügt) 

• Eine Klasse Verbraucher (Unterklasse von Thread), Verbraucherprozess - mehrfach 

instanziiert; alle Verbraucher „streiten“ sich um die Ressourcen 

• Ein Hauptprogramm: legt fest, wie viele Exemplare der Ressource es gibt, startet die 

Verbraucher. 



Der Monitor: 

class Monitor { 

// Anzahl der verfügbaren Ressourcen, diese Variable 

private int vorhanden; 

// wird überwacht! 

Monitor(int v) { vorhanden = v; } // Initialisierung mit der Maximalzahl 

synchronized void anfordern(int n, int wer) { ... } 

// Mit dieser Anfrage an den Monitor fordert der Verbraucher “wer” 

// insgesamt n Elemente der Ressource an 

(136) 

} 

synchronized void freigeben(int n, int wer) { ... } 

// Mit dieser Anfrage gibt der Verbraucher “wer” die von ihm gebrauchten 

// insgesamt n Elemente der Ressourcen zurück 



Verbraucher Nummer “wer” fordert “n” Ressourcen an 

synchronized void anfordern(int n, int wer) 

(137) 

} 

// solange nicht genug verfügbar sind... 

while (vorhanden < n) 

{ // geht der Prozeß in Wartestellung und erwartet, dass man ihn “weckt” 

try { wait(); } catch(InterruptedException e) {} 

} 

// Jetzt ist die while-Schleife zu Ende: Es sind genug Ressourcen vorhanden! 

vorhanden -= n; 

// Her damit! 

// Die Rückgabe: Verbraucher “wer” gibt “n” Ressourcen zurück 

synchronized void freigeben(int n, int wer) { 

vorhanden += n; 

notifyAll(); 

// Die eigentliche Rückgabe 

// Alle wartenden Prozesse werden informiert: Weitermachen 

} 



(138) 

Der Verbraucherprozeß: 

class Verbraucher extends Thread { 

private Monitor mon; // Der Verbraucher merkt sich, welcher Monitor ihn 

bedient 

private int ident, // Identifikation des Prozesses (0, 1, 2, ...) 

wieOft, // Wie oft fordert der Prozess Ressourcen an? 

max; // Wie viele Ressourcen werden maximal angefordert? 

Verbraucher(...) {...} 

// Der übliche Konstruktor 

} 

public void run() 

{ while (wieOft > 0) // Iteration über die Anforderungen 

{ // Wieviel Ressourcen werden angefordert (zwischen 1 und max) 

int anforderung = (int)( Math.random()*(max-1) ) + 1; 

mon.anfordern(anforderung, ident); // Die Anforderung 

// Verwendung der Ressource für 1...1000 ms (Zufall) 

try { sleep( (int)( Math.random()*999 ) + 1); } 

catch(InterruptedException e) {} 

mon.freigeben(anforderung, ident); 

// Die Freigabe 

wieOft--; 

} 

} 



(139) 

Das Hauptprogramm: 

class MonitorMitRessourcen { 

public static void main(String [] args) { 

int vorhanden = 20; 

// Maximal sind 20 Ressourcen verfügbar 

Monitor mon = new Monitor (vorhanden); 

} 

// Erzeugung und starten von 5 Verbrauchern, die jeweils 4 Anforderungen erzeugen 

for (int i=0; i < 5; i++) 

new Verbraucher(mon, i, 4, vorhanden).start(); 

// Alle Verbraucher können maximal "vorhanden" viele Ressourcen anfordern 

} 

MonitorMitRessourcen.java 



Ein typischer Ablauf: 

Verbraucher 0 fordert 15 Elemente an. 

Verbraucher 0 bekommt 15 Elemente. Jetzt verfügbar: 5 






Verbraucher 1 gibt 5 Elemente frei. Jetzt verfügbar: 5 















... 

(140) 



Schema: Gleichartige Ressourcen vergeben 

Ein Monitor verwaltet eine endliche Menge von k ≥ 1 gleichartigen Ressourcen. 

Prozesse fordern jeweils unterschiedlich viele (n) Ressourcen an, 1 ≤ n ≤ k, und geben sie 

nach Gebrauch wieder zurück. 

Die Wartebedingung für das Anfordern ist „Sind n Ressourcen verfügbar?“ 

Zu jedem Zeitpunkt zwischen Aufrufen der Monitor-Methoden gilt: 

„Die Summe der freien und der vergebenen Ressourcen ist k.“ 

Beispiele: 

• Walkman-Vergabe an Besuchergruppen im Museum 

• Vergabe von Parkplätzen 

• Taxi-Unternehmen; n = 1 

auch abstrakte Ressourcen, z. B. 

• das Recht, eine Brücke begrenzter Kapazität (Anzahl Fahrzeuge oder Gewicht) zu befahren. 

auch gleichartige Ressourcen mit Identität: 

• Der Monitor muss dann die Identitäten der Ressourcen in einer Datenstruktur verwalten. 

• Nummern der vom Taxi-Unternehmen vergebenen Taxis 

• Adressen der Speicherblöcke, die eine Speicherverwaltung vergibt 

(141) 



Schema: Beschränkter Puffer 

Ein Monitor speichert Elemente in einem Puffer von beschränkter Größe. 

Produzenten-Prozesse liefern einzelne Elemente, 

Konsumenten-Prozesse entnehmen einzelne Elemente. 

Der Monitor stellt sicher, dass die Elemente in der gleichen Reihenfolge geliefert und 

entnommen werden. (Datenstruktur: Schlange, Queue) 

Die Wartebedingungen 

lauten: 

• in den Puffer schreiben, 

nur wenn er nicht voll 

ist, 

• aus dem Puffer 

nehmen, nur wenn er 

nicht leer ist. 

(142) 



(143) 

Was brauchen wir? 

• Eine Klasse Monitor - die verwaltet die verfügbaren Ressourcen (als Individuen in einer 

Warteschlange) 

• Eine Klasse Produzent (Unterklasse von Thread) - mehrfach instanziiert; alle 

Produzenten wollen ihre „Produkte“ in die Schlange schreiben 

(Operationen enqueue - einspeichern, dequeue – entfernen) 

• Eine Klasse Verbraucher (Unterklasse von Thread) - mehrfach instanziiert; alle 

Verbraucher „streiten“ sich um die in der Schlange verwalteten Produkte 

• Ein Hauptprogramm: startet Produzenten und Verbraucher 



Monitor-Klasse für beschränkte Puffer: 

(144) 

class Buffer { 

private Queue buf; 

// Schlange der Länge n zur Aufnahme der Elemente 

public Buffer (int n) { buf = new Queue(n); } 

// Die Größe n der Schlange modelliert die Begrenztheit des Puffers 

synchronized public void put (Object elem) { ... } 

// Methode zum Ablegen eines neu produzierten Elementes 

} 

synchronized public Object get () { ... } 

// Methode zum Abholen (Verbrauchen) eines Elementes 



(145) 

synchronized public void put (Object elem) { 

// ein Produzenten-Prozess versucht, ein Element zu liefern 

while (buf.isFull()) { 

// warten solange der Puffer voll ist 

try { wait(); } catch (InterruptedException e) {} 

} 

// Jetzt ist es soweit: Puffer ist nicht mehr voll 

buf.enqueue (elem); 

notifyAll(); // jeder blockierte Prozess prüft seine Wartebedingung 

synchronized public Object get () { 

// ein Konsumenten-Prozess versucht, ein Element zu nehmen 

while (buf.isEmpty()) 

// warten solange der Puffer leer ist 

try { wait(); } catch (InterruptedException e) {} 

// Jetzt ist es soweit: Es gibt ein Element - das erste kann “geliefert” werden 

Object elem = buf.first(); 

buf.dequeue(); 

notifyAll(); 

// jeder blockierte Prozess prüft seine Wartebedingung 

return elem; 

} 



Die Produzenten-Klasse: 

(146) 

class Produzent extends Thread { 

String bezeichnung; 

int produktionsZahl; 

Buffer buf; 

// Konstruktor, Übernahme der Grunddaten 

Produzent(String ib, int wieviele, Buffer ibuf) { 

bezeichnung = ib; produktionsZahl = wieviele; buf = ibuf; } 

} 


// Der Produktionsprozess 

while (produktionsZahl > 0) { 

Produkt p = new Produkt("Auto"); // Erzeugen eines neuen Autos 

System.out.println(bezeichnung+" hat "+p+" produziert"); 

// Der Produzent möchte es in die Schlange einreihen 

buf.put(p); 

System.out.println(bezeichnung+" hat "+p+" abgelegt"); 

// Ausruhen... (200 bis 700 ms) 

try { sleep( (int)( Math.random()*500 ) + 200 ); } 

catch (InterruptedException e) {} 

produktionsZahl--; 

} 

} 



(147) 

Die Konsumenten-Klasse 

class Konsument extends Thread { 


int verbrauchsZahl; 

Buffer buf; 

//Konstruktor, Übernahme der Grunddaten 

Konsument(String ib, int wieviele, Buffer ibuf) { 

bezeichnung = ib; verbrauchsZahl = wieviele; buf = ibuf; } 

// Der Konsumprozess 


while (verbrauchsZahl > 0) { 

Produkt p = (Produkt)buf.get(); // Anforderung eines Produktes 

System.out.println(bezeichnung+" entnimmt "+p); 

// Verbrauchen (500 ... 2000 ms) 

try { sleep( (int)( Math.random()*1500 ) + 500 ); } 

catch (InterruptedException e) {} 

verbrauchsZahl--; 

} 

} 

} 



Die Warteschlange Queue als Hilfsmittel für den Monitor: 

Kennt folgende Methoden 

• Einhängen eines neuen Objektes (ganz hinten anstellen!): 

void enqueue(Object o) 

• Entfernen des vordersten Objektes: 

void dequeue() 

• Angabe des vordersten Objektes: 

Object first() 

• Test, ob die Schlange „voll“ ist (begrenzte Kapazität!): 

boolean isFull() 

• Test, ob die Schlange leer ist: 

boolean isEmpty() 

Queue-Methoden werden angereichtert um Ausgabeanweisungen bei enqueue und dequeue 

(damit man sieht was passiert) 

(148) 



(149) 

Hilfsklasse Produkt: 

class Produkt { 


int id; 

// Klassenvariable zählt einfach alle Produkt-Objekte von 1...n durch 

static int anzahl = 0; 

// Das i-te Produkt heißt “Auto(i)” 

public String toString() { return bezeichnung+"("+id+")"; } 

} 

Produkt(String ib) { bezeichnung = ib; id = ++anzahl; } 



Hauptprogramm: 

(150) 

class MonitorMitPuffer { 

public static void main(String [] args) { 

Buffer puffer = new Buffer(20); 

// Lager nimmt max. 20 Autos auf 

// Die Produzenten und ihre Leistungsfähigkeit: 10 VWs, 3 BMWs, ... 

new Produzent("VW", 10, puffer).start(); 

new Produzent("BMW", 3, puffer).start(); 

new Produzent("Mercedes", 2, puffer).start(); 

new Produzent("Trabant", 18, puffer).start(); 

} 

// Die Konsumenten und ihre Gier: 3 Autos für Heike, 10 für Thomek, ... :-) 

new Konsument("Andreas", 3, puffer).start(); 

new Konsument("Thomek", 10, puffer).start(); 

new Konsument("Gero", 5, puffer).start(); 

new Konsument("Gunnar", 4, puffer).start(); 

new Konsument("Gerd", 8, puffer).start(); 

// Es werden 33 Autos hergestellt und 30 abgenommen 

} 

MonitorMitPuffer.java 



(151) 

Typisches Ergebnis (links: Puffergröße 20 – rechts: Puffergröße 2) 

VW hat Auto(1) produziert 

Einspeichern von Auto(1) Anzahl: 1 

VW hat Auto(1) abgelegt 

BMW hat Auto(2) produziert 


BMW hat Auto(2) abgelegt 

Mercedes hat Auto(3) produziert 


Mercedes hat Auto(3) abgelegt 

Trabant hat Auto(4) produziert 


Trabant hat Auto(4) abgelegt 

Entnahme von Auto(1) Anzahl: 4 

Andreas entnimmt Auto(1) 


Thomek entnimmt Auto(2) 


Gero entnimmt Auto(3) 

...... 

VW hat Auto(1) produziert 


VW hat Auto(1) abgelegt 

BMW hat Auto(2) produziert 


BMW hat Auto(2) abgelegt 

Mercedes hat Auto(3) produziert 

Trabant hat Auto(4) produziert 



Mercedes hat Auto(3) abgelegt 

Andreas entnimmt Auto(1) 



Trabant hat Auto(4) abgelegt 

....

2 NebenlÃ¤ufigkeit, Threads und Synchronisation

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?