Problem bei der Synchronisierung von Threads (wait&notif

[Ortega456]

Hallo,

momentan experimentiere ich mit Threads und habe mir das unten stehende Beispielprogramm KonsumentProduzent angeschaut.
Eigentlich sollte ein Konsument (siehe Ausgabe) kein Produkt (modelliert durch einen Integer Wert) verbrauchen koennen, wenn es noch nicht produziert wurde aber laut Ausgabe geschieht genau dies (3 konsumiert, bevor es konsumiert wurde)!

Wo liegt also der Fehler???

public class KonsumentProduzent {
	public static void main(String[] args) {
		Produkt c = new Produkt(); //Neue Produktklasse erstellen
			
		    (new Produzent(c)).start(); //Instanz eines Produzenten-Threats
		    (new Verbraucher(c)).start(); //Instanz eines Konsumenten-Threats
	}
}


class Produkt{ 
	private int dasProdukt; //Ein Metaprodukt modelliert ueber einen Integerwert
	private boolean verfügbar = false; //Variable, die anzeigt, ob ein Produkt zum Verbrauch vorhanden ist
	
	public synchronized int verbraucht() {  //Methode, welche ein Produkt verbaucht, falls es forhanden ist
		while (verfügbar == false) {
			try {
				wait();
			} 
			catch (InterruptedException e) { }
		}
		
                                verfügbar = false; //Produkt wurde verbaucht
		notify();  //jetzt kann Produziert werden
		return dasProdukt;
	}
	public synchronized void produziert(int produktWert) { //Methode, die ein neues Produkt erzeugen soll
		while (verfügbar == true) {
			try {
				wait();
			} 
			catch (InterruptedException e) { }
		}
		
		dasProdukt = produktWert; //Neues Produkt erstellen
                                notify(); //Jetzt kann verbaucht werden
		verfügbar = true;
		
	}
}


class Produzent extends Thread {
	private Produkt einProdukt;
	Produzent(Produkt c) { einProdukt = c; }
	public void run() { //Start der Produktionsphase
		for (int i=0; i<10; i++) {
			einProdukt.produziert(i); //Es werden 10 Artikel produziert
			System.out.println(i + " produziert");
		}
	}
}
class Verbraucher extends Thread {
	private Produkt einProdukt;
	Verbraucher(Produkt c) { einProdukt = c; }
	public void run() {
		for (int i=0; i<10; i++) { //Produzierte Artikel werden verbraucht
			System.out.println(einProdukt.verbraucht() + " konsumiert");
		}
	}
}

Hier die Ausgabe des Programms:

0 produziert
1 produziert
0 konsumiert
2 produziert
1 konsumiert
2 konsumiert
3 konsumiert
3 produziert
4 konsumiert
4 produziert
5 produziert
6 produziert
5 konsumiert
7 produziert
6 konsumiert
7 konsumiert
8 konsumiert
8 produziert
9 konsumiert
9 produziert

Danke!

 

[na-oma]

Es tritt sogar weiter vorn ein anderer Fehler auf:

Du hast willst einen Produzenten bauen, der maximal ein Produkt erzeugen kann. dann legt er sich schlafen (wait) und wird erst nach dem verbrauchen des Konsumenten wieder geweckt. Und nur, wenn das Produkt auch verbraucht wurde, wird ein neues erzeugt.
So schaut auch der Code aus.

Allerdings:

0 produziert
1 produziert

Das heisst, der Produzent produziert 2 Produkte. Das darf nicht sein, denn eines ginge verloren.

Haha, hab den "Fehler" entdeckt:

Wenn man folgenden Code verwendet:

package javaforum;

public class KonsumentProduzent {
	public static void main(String[] args) {

		Produkt c = new Produkt(); // Neue Produktklasse erstellen

		(new Produzent(c)).start(); // Instanz eines Produzenten-Threats
		(new Verbraucher(c)).start(); // Instanz eines Konsumenten-Threats
	}
}

class Produkt {
	private int		dasProdukt;			// Ein Metaprodukt modelliert ueber
	// einen Integerwert
	private boolean	verfügbar	= false;	// Variable, die anzeigt, ob ein

	// Produkt zum Verbrauch vorhanden
	// ist

	public synchronized int verbraucht() { // Methode, welche ein Produkt

		// verbaucht, falls es forhanden ist

		while (verfügbar == false) {
			try {
				wait();
			} catch (InterruptedException e) {
			}
		}

		verfügbar = false; // Produkt wurde verbaucht
		notify(); // jetzt kann Produziert werden
		System.out.println("Kons: after notify");
		return dasProdukt;
	}

	// Methode, die ein neues Produkt erzeugen soll
	public synchronized void produziert(int produktWert) {
		while (verfügbar == true) {
			try {
				System.out.println("Prod: starting waiting");
				System.out.println(verfügbar);
				wait();
				System.out.println(verfügbar);
				System.out.println("Prod: after waiting");
			} catch (InterruptedException e) {
			}
		}

		dasProdukt = produktWert; // Neues Produkt erstellen
		notify(); // Jetzt kann verbaucht werden
		verfügbar = true;

	}
}

class Produzent extends Thread {
	private Produkt	einProdukt;

	Produzent(Produkt c) {

		einProdukt = c;
	}

	public void run() { // Start der Produktionsphase

		for (int i = 0; i < 10; i++) {
			einProdukt.produziert(i); // Es werden 10 Artikel produziert
			System.out.println(i + " produziert");
		}
	}
}

class Verbraucher extends Thread {
	private Produkt	einProdukt;

	Verbraucher(Produkt c) {

		einProdukt = c;
	}

	public void run() {

		for (int i = 0; i < 10; i++) { // Produzierte Artikel werden verbraucht
			System.out.println(einProdukt.verbraucht() + " konsumiert");
		}
	}
}

sieht man villeicht etwas besser was passiert:

0 produziert
Prod: starting waiting
true
Kons: after notify
false
Prod: after waiting
1 produziert

Es wird produziert, gewartet, verbraucht(ohne ausgabe!) notified. Dann wird verbraucht() verlassen, der Monitor wird freigegeben, der Verbraucherthread gibt sofort(d.h. genau dann, wenn er zurückkehrt) die Kontrolle ab, ohne dass diese Ausgabe ausgeführt wird:
System.out.println(einProdukt.verbraucht() + " konsumiert");

Wenn der Producer gerade wartet, wird seelenruhig weiterproduziert, Producer-thread gibt "Produziert" aus, will wieder Porduzieren, muss aber schlafen. Konsumer-thread kann jetz endlich seine Ausgabe des ersten konsumierten Produktes machen.

Wenn der Producer gerade nicht wartet, kann es auch sein, dass der Konsumer-Thread weiter ausgeführt wird. Dadurch können auch normale Fälle auftreten, wo alles so funzt, wie du es willst.

Dein ursprünglicher Fehler entsteht ähnlich:

es wird konsumiert, konsumer wartet, producer produziert(ohne ausgabe, er mach notify und wird suspendiert), Konsumer wacht auf und konsumiert, notified (niemand ist gerade am warten, deshalb suspendiert er nicht und ist weiter aktiv) und gibt die "Konsumiert" Ausgabe aus.

Es ist also alles korrekt. Es wird immer nur 1 Produziert, verbraucht, weider produziert etc. Bis auf die Ausgabe, die stimmt nicht!

Sorry, wenn das alles etwas durcheinander ist. Die liebe UhrZeit ist nicht mein Freund.


Wie man das lösen könnte:

-Ausgabe in den synchroniced Methoden machen. Weiss nicht, ob das gut ist. Kommt immer auf die Anwendung an.

-?? Wie macht man sowas i.A.?

 

[mic_checker]

Ich hab mir nicht mehr alles durchgelesen, aber das oder sollte man vielleicht sagen ein Problem besteht darin das du unterschiedliche Wartebedingungen hast.

Da gibts eine ganz einfache Merkregel:
Verwende notifyAll() wenn:
1) Unterschiedliche Wartebedingungen vorliegen
2) Mehrere Threads weiterlaufen könnten.

du darfst dich natürlich auch nicht drauf verlassen das aus der Warteschlange immer der richtige Thread wieder aufgeweckt wird, darin besteht ja u.a. die Grundproblematik dieses grundsätzlichen Problems.

Beachte noch folgendes:
Nur weil die Ausgabe falsch ist muss das Programm nicht falsch sein, gerade bei Threads können in der Ausgabe manchmal scheinbar kleine Fehler auftauchen, wobei das Programm ordnungsgemäß funktioniert. Also erstmal genau untersuchen ob Fehler wirklich vorhanden ist.

 

[Ortega456]

Alles klar, danke fuer die Beitraege!

habe mal nach der Produktion/Verbrauch den jeweiligen Thread mal mit sleep(1000) schlafen lassen und siehe da, die Ausgabe ist in Ordnung.
Anonsten ist wirklich die Loesung die System.out.println(...) in die entsprechenden Methoden zu verschieben.

 

[mic_checker]

Hast du denn notify durch notifyAll ersetzt? Falls nicht dann kann es zwar sein das dein Programm die richtige Ausgabe anzeigt, aber das ist dann eher vom Zufall abhängig.