Threads abwechseln lassen mit wait() und notify()

[pr0ggr]

Hallo,

Ich hab nen Thread, in dem die GUI läuft (main Thread) und nen Thread in dem der Algorithmus läuft, der halt die Informationen für die GUI liefert.
Das was ich nicht hinbekomm ist dass die beiden Threads nacheinander laufen (ich weiss das hört sich doof an aber lest weiter).
Der Algorithmus besteht logischwerweise aus ner Schleife welche in der run-Methode ausgeführt wird. Die GUI demonstriert sozusagen die Funktionsweise des Algorithmus.
Deshalb soll der Algorithmus nur schrittweise ausgeführt werden, immer wenn ich in der GUI auf nen Button klicke. Gegen Anfang wartet er mit wait(). Dann wenn er aufgeweckt wird macht er ein paar Sachen und soll dann den GUI Thread informieren und sich wieder schlafen legen. Der GUI Thread legt sich nämlich ebenfalls schlafen nach dem er den Algorithmus-Thread aufgeweckt hat.

(algorithm-Thread):

    	    public void run() {
    		try {
    		    synchronized(this){wait();}
    		    //Initialisierung blablabla
    		    synchronized(superthread){superthread.notify();wait();}
    		    do {
    			// Ein paar Zeilen Code hier
    				synchronized(superthread){superthread.notify();wait();}
    			 // Noch ein bisschen Code
				synchronized(superthread){superthread.notify();wait();}
			//usw.
    		    } while(bedingung);
    		} catch(Exception e) { e.printStackTrace(); }
    	    }

Methode die ausgeführt wird wenn der Button geklickt wird (im superthread).

	private void change() {
	    try {
		synchronized(algorithm){algorithm.notify();wait();}
	    } catch (InterruptedException e) {
		e.printStackTrace();
	    }
	    
	   //Code um die GUI zu aktualisieren
	}

Im Prinzip sollen sich die Threads also gegenseitig aufwecken, eine Nebenläufigkeit per se ist also nicht gegeben. Mir erschien das als die einfachste Möglichkeit einen Algorithmus nur Schrittweise arbeiten lassen zu können und trotzdem normal implementieren zu können.

Das Problem ist jetzt jedoch, dass ich die ganze Zeit java.lang.IllegalMonitorStateException geworfen bekomme und ich weiss einfach nicht mehr weiter.
Es liegt wahrscheinlich daran dass ich für die wait()-Methode nicht den Monitor des eigenen Objektes besitze, aber wenn ich notify und wait in je eigene synchronized-Blöcke schreib dann kann es ja sein dass die beiden Methoden nicht nacheinander ausgeführt werden ohne dass der Scheduler umschält.

Is bestimmt voll das noob Problem, aber mir fällt echt nichts dazu ein.

 

[SlaterB]

an wait() führt kein synchronized vorbei, soviel ist klar,

trivial ist das ganze nicht, synchronized ineinander kann mit Pech zu Deadlocks führen,
dazu gibt es sicher ausführliche Links im Internet, ich kann aber keine nennen,

(a)
meinen bisherigen Überlegungen dazu nach sollte es genügen, wenn man sich auf eine Richtung allgemein festlegt:
wann immer zu erwarten ist, dass sowohl (einer von mehreren?) Algorithm und der Superthread beteiligt sind,
erst auf den Algorithmus synchronized, dann auf den anderen, oder umgekehrt,
ist wichtig dass das überall passiert,

gefährlich sind bei mir beliebige Methoden, die scheinbar nur für sich synchronized sind, dann intern, evtl. über mehrere Aufruf-Ebenen, doch noch zur anderen Seite kommen..

gefährlich wird es auch, wenn etwa mehrere Algorithm aus deinem Programm untereinander kommunizieren..

----------

(b)
falls du bei dir ausschließlich wait/notify zu bedienen hast, nicht normale Methoden schützen willst,
müsste eine noch einfachere Alternative ein drittes synchronized sein, auf ein global verfügbares drittes Objekt nur für diesen Zweck der Kontrolle aller wait/notify,
dort kann immer nur einer sein und solange auf beliebige Threads wait/notify aufrufen,
für diese dann auch ruhig neue Methoden erstellen wain(x); so das synchronized einbaut ist, spart Tipparbeit,

auf diese Weise ist sichergestellt, dass der Aufrufer schläft, bevor der Aufgerufene drankommt,
und dieser nicht super schnell arbeiten kann und schon das notify() losschickt, bevor der Aufrufer selbst schlafen geht,
ohne dass ihn jemals noch wer weckt,
mit (a) ist das nicht zu erreichen, dein Code versucht das ja, aber mit Deadlock-Gefahr

edit:
(c)
ach ja, was ich noch schreiben wollte: wenn es nur einen Algorithmus + nur einen SuperThread gibt,
dann reicht auch ein Objekt an dem alle warten + notifyen, eines der beteiligten Thread-Objekte oder ein beliebiges drittes Objekt

 

[tfa]

Eine Alternative zur Low-Level-Synchronisation mit wait/notify können Locks und Conditions bieten. Das ist auf jeden Fall ein Blick wert. Beispiel: http://www.java-forum.org/blogs/tfa/19-snippet-synchronisation-locks-conditions.html