Monitor: wait() und notify()

[Luk10]

Grüße,

In der Schule lernen wir gerade das Monitor-Prinzip zur sychornisation von Prozessen.

Wir verwenden zur Veranschaulichung folgendes "Modell":

> Klasse Schreiber, Leser [extends Thread]
> Klasse Puffer

Beide Klassen, Schreiber und Leser wollen auf eine Variable im Puffer zugreifen und diese ändern (Methoden in Puffer: schreibe() und lese(), beide sychronized).

Da ich leider den Code aus dem Unterricht nicht da habe, bräuchte ich jemanden der mir einen gute Erklärung linkt, oder mir hier gibt zu folgendem:

Wie werden die Threads im Puffer registriert bzw gespeichert? Was genau machen wait() und notify() und wann muss ich sie aufrufen bzw wie werden sie verwendet?

Danke,
-Luk10-

 

[Lybrial]

Hallo Luk10,

also wait () setzt du ein, wenn du einem Thread sagen möchtest, dass deine Ressource gerade von einem anderen Thread benutzt wird und er deswegen warten soll.

Notify () benutzt du, um dem Thread widerrum mitzuteilen, dass die Ressource nun wieder fregegeben ist und genutzt werden kann.

Dabei gilt das Notify () dem Thread, der als erstes wait () ausgeführt hat.#

Es gibt eine weitere Methode, notifyAll (), diese sagt allen Threads das die Ressource wieder frei ist, nicht nur dem einen.

 

[xehpuk]

Hey,

meines Erachtens sind alle Ausführungen meines Vorposters falsch.

Wenn Englisch kein Problem ist, würde ich einfach mal ins offizielle Tutorial reinschauen: Lesson: Concurrency (The Java™ Tutorials > Essential Classes)
Ansonsten kann ich die Kolumne "Effective Java" empfehlen: AngelikaLanger.com - Effective Java - A column by Angelika Langer & Klaus Kreft - Angelika Langer Training/Consulting
Dort die Einträge zu "Concurrency".

Mit Nebenläufigkeit muss man sich schon eine Weile beschäftigen. Falscher Umgang mit Threads ist eine häufige Fehlerursache.

 

[Lybrial]

notify:

Object (Java 2 Platform SE v1.4.2)

notifyAll:

Object (Java 2 Platform SE v1.4.2)

wait:

Object (Java 2 Platform SE v1.4.2)


Wo genau waren meine Aussagen nun falsch?

 

[Luk10]

Danke für die Antworten & Links ...

Leider hilft mir beides nicht wirklich, weil das viel zu umfangreich ...
Rufe ich wait() und notify() auf die Threads auf? Oder auf den Puffer?

Wie wird geregelt, dass die Threads nacheinander dran kommen?

Danke,
Luk10

 

[Lybrial]

Pseudo-Code:

public synchronized void startWriting ()
{
    if (anderer Thread greif auf Puffer zu)
    {
        wait ();
    }
    else
    {
        // schreibe in den Puffer
    }
}

public synchronized void finishedWriting ()
{
    // thread ist fertig mit schreiben
    notify ();
}

 

[Luk10]

Auf was wird wait() und notify ausgerufen? Wie wird der bestimmt wer der nächste an der Reihe ist?

Luk10

 

[Lybrial]

Dann werde ich mal etwas genauer

Also du hast eine Klasse die den Zugriff auf eine Daten-Ressource Steuert.
Wir nehmen hier einfach mal an, dass du nur mit einem Thread gleichzeitig
auf die Ressource zugreifen kannst, das simuliere ich einfach mal mit einem Counter.

public class SomeClass 
{	
	private int count = 0;
	
	public synchronized void write (Data aData) throws InterruptedException
        {
		while(currentCarCount >= 1) {
			wait();  
		}
		
                count++;           // count = 1, also kann kein weiter Thread drauf zugreifen
                System.out.println(aData.mId + " Ressource wird genutzt!");
		System.out.println(count);
	}
	
	public synchronized void stopWriting (Data aData) 
        {
                count--;
		System.out.println(aData.mId + " wird nicht mehr genutzt!");
		System.out.println(count);
		
		notifyAll();
	}

}

public class Data extends Thread 
{	
	private SomeClass someClass;
        private int mId;
	
	public Data(SomeClass someClass, int mId) 
       {
		this.someClass = someClass;
		this.mId = mId;
	}

	public void run() 
       {
		while(!isInterrupted()) 
                {
			try 
                        {
				someClass.write(this);
				sleep(Math.abs(new Random().nextLong() % 2000));
				someClass.stopWriting(this);
				sleep(Math.abs(new Random().nextLong() % 2000));
			}
			catch(InterruptedException e) 
                        {
				interrupt();
			}
		}
	}
}

public class Test 
{
	public static void main(String[] args) throws InterruptedException
        {
		someClass someClass = new SomeClass ();

                Data d1 = new Data (someClass, 1);
                Data d2 = new Data (someClass, 2);
                Data d3 = new Data (someClass, 3);
		
		d1.start();
		d2.start();
		d3.start();
		
		Thread.sleep(30000); // Das Programm läuft so 30 sekunden lang
		
		d1.interrupt();
		d2.interrupt();
		d3.interrupt();  // dann wirds abgebrochen
	}

}

Keine Garantie auf korrekte Syntax, ich habe das jetzt schnell so ohne es zu Testen direkt hier reingeschrieben

 

[xehpuk]

wait () setzt du ein, wenn du einem Thread sagen möchtest, dass deine Ressource gerade von einem anderen Thread benutzt wird und er deswegen warten soll.

Woher hast du das denn? Ein Thread kommt erst gar nicht zu einem

wait()

, wenn bereits ein Thread im synchronisierten Bereich ist, weil eben immer nur höchstens ein Thread im (zum selben Objekt) synchronisierten Bereich sein kann. Ein zweiter Thread würde also vorm

synchronized

warten müssen.

Dabei gilt das Notify () dem Thread, der als erstes wait () ausgeführt hat.#

Nein, siehe die von dir selbst verlinkte javadoc zu

notify()

.

Sagen wir mal, es gibt beim Puffer einen Konsumenten(thread) und einen Produzenten(thread). Der Konsument kann nur etwas aus dem Puffer nehmen, wenn dieser nicht leer ist. Ist also dieser leer, wartet dieser. Hat der Produzent nun etwas in den Puffer getan, ist dieser ja nicht mehr leer, also benachrichtigt er im Anschluss den Konsumenten.
Ist der Puffer begrenzt, muss man das Ganze auch noch andersherum betrachten. Ist der Puffer voll, muss der Produzent warten, bis der Konsument etwas herausgenommen hat und diesen im Anschluss benachrichtigt.

Es bietet sich an, die Synchronisierung an dem Puffer vorzunehmen (daraus folgt, dass auch

wait()

und

notify()

darauf aufgerufen werden).