IllegalMonitorStateException che non capisco

[Java_Machine]

allora alle volte tipo una volta su 4 che testo il mio programma mi da questa IllegalMonitorStateException, vi posto la sezione di codice..



Turnox[f].sem.signal(Turnox[f],S); /*risveglia il giocatore*/



while(this.S==1){
try {
wait();
}

catch (InterruptedException e) {}
}
}
}



public class Semaphore {

Giocatore g;
int S;

public Semaphore(int S){

this.S=S;

}



public void signal(Giocatore gio,int S) {
this.g=gio;
this.S=S;

S--;

if (S==0) {
synchronized(g){
g.notify();/*risveglia il giocatore*/
}
}
}

}

[andbin]

Originariamente inviato da Java_Machine
allora alle volte tipo una volta su 4 che testo il mio programma mi da questa IllegalMonitorStateException, vi posto la sezione di codice..

Una regola fondamentale nell'uso di wait/notify è che questi metodi vanno invocati esclusivamente su un oggetto di cui si possiede il lock. Altrimenti viene appunto lanciata la eccezione IllegalMonitorStateException.

Ora ... dal codice si vede che c'è un notify() che è invocato su un oggetto di cui si possiede certamente il lock (c'è il synchronized su quell'oggetto). Vedo che c'è anche un wait() ma non si capisce se in quel punto si possiede il lock sul 'this' (l'oggetto corrente).

[Java_Machine]

come faccio a vedere se ho il lock sul this?

help!!

[andbin]

Originariamente inviato da Java_Machine
come faccio a vedere se ho il lock sul this?

Quel wait() è all'interno di un metodo di istanza marcato synchronized? O è dentro un blocco synchronized(this)??

Ma poi c'è un'altra questione. Da quelle poche righe di codice che hai postato, non si può chiaramente capire molto su cosa devi fare e su come è fatto tutto il tuo codice. Quindi non ho idea se quel wait() e quel notify() sono o dovrebbero essere correlati tra di loro.

Però in genere wait/notify si usano su uno stesso oggetto. Cioè un thread A fa un wait() su un oggetto X se sa che deve attendere qualcosa e poi un thread B "produce" un qualcosa e fa un notify() su quello stesso oggetto X per segnalare la cosa all'altro thread. Quindi per queste cose il lock è lo stesso.

[Java_Machine]

il wait e dentro un blocco syn..(this)...

Il gioco dovrebbe funzionare così il thread a sveglia il thread b e poi si mette in attesa

[andbin]

Originariamente inviato da Java_Machine
il wait e dentro un blocco syn..(this)...

Allora tecnicamente è ok.

Originariamente inviato da Java_Machine
Il gioco dovrebbe funzionare così il thread a sveglia il thread b e poi si mette in attesa

Ma da quel codice posso solo vedere che il wait lo fai sul 'this' (e quale oggetto sia realmente non lo so) mentre il notify lo fai su un oggetto di tipo Giocatore.

Quindi a prima vista direi che quel wait non ha nulla a che fare con quel notify. Ma ovviamente non posso esserne certo ...

[Java_Machine]

ti posto il blocco che sta dentro al run di ogni oggetto giocatore

synchronized(this){


if(verifica==true){/*se ha finito le carte stampa risveglia il giocatore successivo e si interrompe*/

Thread.currentThread().interrupt();

if(Thread.currentThread().isInterrupted())
{

System.out.println("Ho perso e sono uscito dal gioco sono il numero "+(v_giocatore));


for(int m=0;m<n;m++){

Turnox[m].numero_giocatori=(Turnox[m].numero_giocatori)-1;
}

Turnox[f].sem.signal(Turnox[f],S);/*risveglia il giocatore*/
return;
}
}
else{

Turnox[f].sem.signal(Turnox[f],S); /*risveglia il giocatore*/

}

while(this.S==1){
try {
wait();
}

catch (InterruptedException e) {}
}
}
}


}

[Java_Machine]

nessuna idea?