Synchronisation von Threads

[h4nso]

Hallo,

mein Problem ist so, zwei Threads (Thread1 & Thread2) warten auf ein Thread (Thread3). Thread3 macht ein notifyAll(),
aber nur das erste Thread, das in der wait()-queue ist, macht danach weiter.
Das andere Thread blockt 4 ever!

Weiß jemand an was das liegt oder was ich falsch gemacht haben könnte?

Außerdem habe ich noch zwei Fragen zur Synchronisation!
1.) Was ist der Unterschied zwischen notify() und notifyAll()? Ich habe gedacht alle Objekte, die auf das notify warten werden damit benachrichtigt!

2.) Wenn ein notify() gemacht wird (Thread3) und einer / beide Warte-Threads (Thread1 & Thread2) sind noch nicht in der wait() Methode,
werden diese Threads dann immer im wait() bleiben?

Vielen Dank schon mal im vorraus, ich hoffe ohne Code ist mein Problem verständlich, ansonsten kann ich noch ein kleines Beispiel zusammenstellen.

 

[SlaterB]

> Das andere Thread blockt 4 ever!
> Weiß jemand an was das liegt oder was ich falsch gemacht haben könnte?

kommt später kein weiteres notify? dann liegts daran,
ansonsten ist deine Beschreibung nicht ausreichend

'ich habe ein Programm und es geht nicht',
aha, kein Wunder

> ansonsten kann ich noch ein kleines Beispiel zusammenstellen

gute Idee

--------

1)
google? da gibts gleich direkte Vergleiche

2)
warum sollte nicht wenigstens einer raus dürfen?
ob der andere für immer drin bleibt, hängt wohl davon ab, ob für immer nie wieder notify() aufgerufen wird

 

[Niki]

notify() weckt genau einen beliebigen Thread auf, der sich im wait-Pool dieses Monitors befindet.
notifyAll() weckt alle auf diesen Monitor wartenden Thread auf.

Kontrollier doch mal, ob alle Objekte auf den selben Monitor syncen. Wenn vor dem wait das notify aufgerufen wird, wartet der Thread natürlich für immer. Deshalb vielleicht auch mit flags arbeiten, dann kann sowas nicht passieren.

 

[h4nso]

ok, ich glaube da müsst Ihr mir doch ein wenig unter die Arme greifen. Dieses Beispiel ähnelt dem relevanten Part in meinem Programm:

Main.java

public class Main {

    public static void main(String[] args) {
        Thread3 t3 = new Thread3();

        new Thread1(t3);
        new Thread2(t3);
    }

}

Thread1.java

public class Thread1 implements Runnable {

	private Thread runner;
	private Thread3 t3;
 
    public Thread1(Thread3 t3) {
    	this.t3 = t3;
        this.runner = new Thread(this,"Thread1");
        System.out.println("Thread1 will start now ...");
        this.runner.start();
    }
 
    public void run() {
        System.out.println("Thread1 will wait for Thread3 ...");
        try {
        	if(!this.t3.isFinished()) {
        		synchronized(this.t3) {
        			this.t3.wait();
        			System.out.println("Thread1 finished Waiting, go on with process ...");
        		}
        	}
        } catch(InterruptedException e) {}
        System.out.println("Thread1 finished!");
    }

}

Thread2.java

public class Thread2 implements Runnable {

	private Thread runner;
	private Thread3 t3;
 
    public Thread2(Thread3 t3) {
    	this.t3 = t3;
        this.runner = new Thread(this,"Thread2");
        System.out.println("Thread2 will start now ...");
        this.runner.start();
    }
 
    public void run() {
        System.out.println("Thread2 will wait for Thread3 ...");
        try {
        	if(!this.t3.isFinished()) {
        		synchronized(this.t3) {
        			this.t3.wait();
        			System.out.println("Thread2 finished Waiting, go on with process ...");
        		}
        	}
        } catch(InterruptedException e) {}
        System.out.println("Thread2 finished!");
    }

}

Thread3.java

public class Thread3 implements Runnable {

    private Thread runner;
    private boolean finished;
 
    public Thread3() {
        this.runner = new Thread(this,"Thread3");
        this.finished = false;
        System.out.println("Thread3 will start now ...");
        this.runner.start();
    }
 
    public void run() {
    	try {
    		synchronized(this) {
    			Thread.sleep(3000);
    			System.out.println("Thread3 finished with important process, other Threads can go on!");
    			this.finished = true;
    			this.notifyAll();
    		}
    	} catch(InterruptedException e) { }
        System.out.println("Thread3 finished!");
    }

    public boolean isFinished() {
    	return this.finished;
    }

}

Also Thread3 muss erst ausgeführt werden, bevor Thread1 und 2 weitermachen können!
Das Beispiel erzeugt folgende Ausgabe:

Thread3 will start now ...
Thread1 will start now ...
Thread1 will wait for Thread3 ...
Thread2 will start now ...
Thread2 will wait for Thread3 ...
Thread3 finished with important process, other Threads can go on!
Thread3 finished!

Jetzt soll aber noch anschließende Thread1 und 2 weitermachen, doch es blockiert.
In meinem Programm bekommt aber eins von beiden ein notify und macht weiter, der andere nicht.

> Kontrollier doch mal, ob alle Objekte auf den selben Monitor syncen.
Wie kann ich den das herausfinden?

Wie könnte ich das jetzt so umsetzen wie ich das möchte?

 

[h4nso]

ok, ich glaube da müsst Ihr mir doch ein wenig unter die Arme greifen. Dieses Beispiel ähnelt dem relevanten Part in meinem Programm:

Main.java

public class Main {

    public static void main(String[] args) {
        Thread3 t3 = new Thread3();

        new Thread1(t3);
        new Thread2(t3);
    }

}

Thread1.java

public class Thread1 implements Runnable {

	private Thread runner;
	private Thread3 t3;
 
    public Thread1(Thread3 t3) {
    	this.t3 = t3;
        this.runner = new Thread(this,"Thread1");
        System.out.println("Thread1 will start now ...");
        this.runner.start();
    }
 
    public void run() {
        System.out.println("Thread1 will wait for Thread3 ...");
        try {
        	if(!this.t3.isFinished()) {
        		synchronized(this.t3) {
        			this.t3.wait();
        			System.out.println("Thread1 finished Waiting, go on with process ...");
        		}
        	}
        } catch(InterruptedException e) {}
        System.out.println("Thread1 finished!");
    }

}

Thread2.java

public class Thread2 implements Runnable {

	private Thread runner;
	private Thread3 t3;
 
    public Thread2(Thread3 t3) {
    	this.t3 = t3;
        this.runner = new Thread(this,"Thread2");
        System.out.println("Thread2 will start now ...");
        this.runner.start();
    }
 
    public void run() {
        System.out.println("Thread2 will wait for Thread3 ...");
        try {
        	if(!this.t3.isFinished()) {
        		synchronized(this.t3) {
        			this.t3.wait();
        			System.out.println("Thread2 finished Waiting, go on with process ...");
        		}
        	}
        } catch(InterruptedException e) {}
        System.out.println("Thread2 finished!");
    }

}

Thread3.java

public class Thread3 implements Runnable {

    private Thread runner;
    private boolean finished;
 
    public Thread3() {
        this.runner = new Thread(this,"Thread3");
        this.finished = false;
        System.out.println("Thread3 will start now ...");
        this.runner.start();
    }
 
    public void run() {
    	try {
    		synchronized(this) {
    			Thread.sleep(3000);
    			System.out.println("Thread3 finished with important process, other Threads can go on!");
    			this.finished = true;
    			this.notifyAll();
    		}
    	} catch(InterruptedException e) { }
        System.out.println("Thread3 finished!");
    }

    public boolean isFinished() {
    	return this.finished;
    }

}

Also Thread3 muss erst ausgeführt werden, bevor Thread1 und 2 weitermachen können!
Das Beispiel erzeugt folgende Ausgabe:

Thread3 will start now ...
Thread1 will start now ...
Thread1 will wait for Thread3 ...
Thread2 will start now ...
Thread2 will wait for Thread3 ...
Thread3 finished with important process, other Threads can go on!
Thread3 finished!

Jetzt soll aber noch anschließende Thread1 und 2 weitermachen, doch es blockiert.
In meinem Programm bekommt aber eins von beiden ein notify und macht weiter, der andere nicht.

> Kontrollier doch mal, ob alle Objekte auf den selben Monitor syncen.
Wie kann ich den das herausfinden?

Wie könnte ich das jetzt so umsetzen wie ich das möchte?

 

[h4nso]

sorry für den doppel-post, der server hat mir eine SQL-Fehlermeldung ausgespuckt und mich zurück verwiesen. Bin nicht davon ausgegangen, dass der Post erstellt wurde.

 

[kleiner_held]

Das Problem ist das Thread 3 zuerst in den synchronized block eintritt und diesen damit quasi blockiert.
Thread 1 und Thread 2 warten also die 3 Sekunden nicht an der Stelle this.t3.wait();
sondern schon vor dem Eintritt in den synchronized block.
Das notifyAll(); von Thread 3 macht damit gar nichts und erst wenn Thread 3 den synchronized block verlaesst koennen die beiden jeweils weiter und bleiben dann an dem wait() haengen das nie ein notify() bekommt.

Loesungsmoeglichkeiten gibt es mehrere, z.B. wenn der relevante Teil von Thread 3 nur das notifyAll() im synchronized ausfuehrt.

Thread.sleep(3000);
System.out.println("Thread3 finished with important process, other Threads can go on!");
this.finished = true;
synchronized(this) {
    this.notifyAll();
}

Wenn du aber nur erreichen willst, das Thread 2 und 1 auf Thread 3 warten, wuerde ich nicht auf synchronized+wait()+notify() zurueckgreifen, sondern einfach auf java.lang.Thread.join()

PS: Es ist ein wenig verwirrend wenn deine Klassen ThreadX heissen aber nicht von Thread erben sondern nur Runable implementieren. Wenn du sowieso ein einmaliges internes Thread objekt mitfuehrst kannst du auch gleich von Thread erben.

 

[h4nso]

ok, so wie du das gepostet hast funktioniert das einwandfrei, auch mit notifyAll().
Ist das jetzt nur Zufall gewesen oder sollte ich wirklich join() verwenden?

Der Grund warum ich von Runnable ableite ist folgender, meine wirklichen Klassen, die auch nicht "ThreadX" heißen,
erben schon von einer abstrakten Klasse und haben somit nur noch die Option "Runnable".

 

[kleiner_held]

Naja Zufall ist es nicht, allerdings muss der jeweilige Zugriff auf die finished variable auf alle Faelle mit in den synchronized block ansonsten gibts Probleme wenn Thread 3 zu schnell ist, also jeweils das

this.finished = true;

und

if(!this.t3.isFinished())

mit in den synchronized block.

Das join() ist in dem Fall einfach nur uebersichtlicher

public class Thread3 implements Runnable {
    private Thread runner; 
    [...]
    public void join() throws InterruptedException {
    	runner.join();
    }
}
  
public class Thread2 implements Runnable {
    [...]
    public void run() {
       System.out.println("Thread2 will wait for Thread3 ...");
       try {
           this.t3.join();
       } catch(InterruptedException e) {}
    }
}

 

[h4nso]

ok hab ich soweit verstanden, aber das mit dem

if(!this.t3.isFinished)

in den synchronized Block ist mir noch ein bisschen unklar.
Soll ich jetzt in der isFinished() Methode den sync machen oder im Thread1 bzw. 2 im run()?

 

[FArt]

Tipp: http://www.javaspecialists.co.za/archive/Issue150.html

 

[kleiner_held]

Es waren die run() Methoden von Thread2 und Thread1 gemeint

public void run() {
        System.out.println("Thread2 will wait for Thread3 ...");
        try {
           synchronized(this.t3) {
              if(!this.t3.isFinished()) {
                 this.t3.wait();
                 System.out.println("Thread2 finished Waiting, go on with process ...");
              }
           }
        } catch(InterruptedException e) {}
        System.out.println("Thread2 finished!");
    }

Achso und ein

private boolean volatile finished = false;

in thread 3 ist wirklich besser.

 

[h4nso]

ok läuft so weit sehr gut =) danke nochmals