Problem mit notify()

[Schachmann]

Hallo Forum,

ich habe unten mal einen kleinen Code angehängt, den ich geschrieben habe um meine Frage zu verdeutlichen.

Es werden 20 Threads gestartet, die nach dem Start schlafen gehen und aufs Wecken warten. Irgendwann wird ein notify() ausgeführt und schafft es den größten Teil der Threads zu wecken. Aber wieso?

Wieso kann ein notify() manchmal sogar alle Threads wecken? Ich würde erwarten, dass das notify() einen Thread weckt (der daraufhin stirbt) und die restlichen Threads müssten doch eigentlich für immer weiterlaufen? Weiterhin würde ich denken, das notifyAll() eben dazu da ist alle Threads zu wecken.

Wenn mir jemand erklären könnte, warum das nicht so ist, wäre ich dankbar.

Gruß,
Ralf

package thread;

class Warter extends Thread {
     Fred f;
    
    public Warter(Fred f) {
        this.f=f;
    }

    @Override
    public void run() {
        System.out.println("Warter ist gestartet");
        synchronized(f) {
            try {
                f.wait();
            } catch (InterruptedException ex) { }
        }
        System.out.println("Warter endet");
    }
}

class Fred extends Thread {
    @Override
    public void run() {
        synchronized(this) {
            notify();
        }
    }
}


public class Main {
    public static void main(String[] args) {
        Fred f=new Fred();

        for(int i=0; i<20; i++) new Warter(f).start();
        
        f.start();
    }
}

 

[SlaterB]

tja, das ist schon seltsam,
wenn du aber anstelle eines Thread ein normales Object nimmst, dann wird bei notify() auch nur einer informiert,
irgendwie wird es mit Thread anders, obwohl dieses notify() nicht überschreibt..

ah, alles klar, wenn der Thread beendet wird, dann wird bestimmt notifyAll() aufgerufen,
kannst du testen, indem du nach dem einfachen notify() noch ein Thread.sleep(2000) einbaust, bis dann der Fred-Thread zu Ende geht

edit:
> und schafft es den größten Teil der Threads zu wecken. Aber wieso?

den Rest nicht, weil die durch die Thread.start()-Zufalls-Verzögerung erst nach dem Ende des Threads ihr wait() ausführen

 

[Schachmann]

Danke für den Tipp!

Das mit dem sleep hat zwar leider nix gebracht, aber der Tipp mit dem normalen Objekt war Gold wert. Wenn ich auf ein x-beliebiges Objekt synchronisiere, dann ist es tatsächlich so, dass notify einen Thread weckt und notifyAll weckt alle Threads. Das ein Thread beim Sterben notifyAll aufruft, ist das eigentlich eine gesicherte Erkenntnis oder eine Vermutung (der ich nach dem Verhalten das sich gezeigt hat eigentlich zustimmen würde)?

Gruß,
Ralf

 

[SlaterB]

Vermutung

bedenke aber auch die Methode Thread.join(), mit ihrem Code

 while (isAlive()) {
		long delay = millis - now;
		if (delay <= 0) {
		    break;
		}
		wait(delay);
		now = System.currentTimeMillis() - base;
	    }

irgendjemand muss die ja aufwecken, das ist ziemlich todsicher ein notifyAll()

 

[Schachmann]

Ja, ja, ich habe eben auf der Heimfahrt nochmal drüber nachgedacht. Es ist schon seeehr plausibel dass ein sterbender Thread nochmal ein notifyAll() aufruft, damit evtl. Schläfer auch mal zum Zug kommen.

Danke nochmals für den Tipp,
Gruß,
Ralf