Newsgroup: it.comp.java
Titolo: Thread deadlock ..... HELP

Salve a tutto il NG ,
ho qualche ...ehm "problemino" con i Thread , infatti per meglio 
comprenderli ho fatto un programmino ,rappresentante un supermarket,
in cui i clienti (Thread) prendono da un Distributore di ticket (tramite 
metodo synchronized daiticket() della classe Distributore) il loro bel 
numerino
e si rivolgono al commesso che li serve in base al loro numero (tramite 
metodo synchronized daipesce()) .
Il problema è che i thread vanno in deadlock !    :(
Se mi potete dare una mano ve ne sarei grato !
ecco un po' di codice :
/************Nel Main****************/
//maxticket=max numero di ticket che eroga
//poi riprende da capo(il distributore..)
Commesso c = new Commesso(maxticket);
Distributore d = new Distributore(maxticket);
int i;
for(i=1;i<=numclient;i++){
Cliente client = new Cliente(i,d,c); // i=ID nelle altre classi
client.start();
}
/************classe Cliente******************/
public class Cliente extends Thread {
        public int ID;
        public Distributore d;
        public Commesso c;
        public int = ticket;
public Cliente(int ID,Distributore d,Commesso c) 
{
this.ID = ID;
this.d = d;
this.c = c;
}
public void run()
{
try {
        sleep((int) (Math.random()*1000))       ;
        ticket = d.daiticket(ID); //ottiene il numerino dal distrib.
}catch(Exception e){}
try {
        sleep((int) (Math.random()*1000))       ;
        c.dammipesce(ticket,ID); //riceve il pesce dal commesso
}catch(Exception e){}
}//end run()
}//end class
/******************classe distributore *************/
public class Distributore {
        public int count=0;
        public int MAX_TICKET;
        public Distributore(int MAX)
        {
                this.MAX_TICKET = MAX;
        }
public synchronized int daiticket(int ID)
{
        if(count == MAX_TICKET) count = 0;
        count++;        
        System.out.println("il cliente "+ID+"ha preso il biglietto"+count);
        return count;
}//end daiticket
}//end class
/********** la classe "inguaiata" Commesso ********/
public class Commesso {
        public int MAX_TICKET;
        public int ticketattuale =1;
public Commesso(int MAX)
{
        this.MAX_TICKET = MAX;
}
public synchronized void dammipesce(int ticket,int ID)
{
//ticket attuale è "il display" a cui i commessi fanno riferimento x 
//servire i clienti
while(ticket != ticketattuale){ 
try {
System.out.println("il cliente "+ID+ "e in attesa");
wait();
notifyAll();
}catch(Exception e){}
}
System.out.println("il cliente "+ID+ "ha ritirato il pesce tramite il 
ticket "+ticket);
if(ticketattuale == MAX_TICKET) ticketattuale = 0;
 ticketattuale++;
} //end dammipesce()
} //end class
Scusate se ho postato tutte le classi , ma penso siano necessarie x 
compredere dov'è l'errore.
Spero vivamente in un vs aiuto e vi ringrazio anticipatamente.
Grazie
RazzO

 Il problema č che i thread vanno in deadlock !    :(


 } //end class
L'errore è proprio in questa classe: hai messo la notifyAll subito dopo la
wait. In questo modo nessuno aspetta. Dovresti spostare la notifyAll subito
dopo l'istruzione ticketattuale++. In questo modo quando il ticket cambia i
clienti vengono notificati e si rimettono a fare la gara per prendere il
pesce. Il primo che piglia il lock sul commesso entra nel metodo e verifica
se è il suo turno. Se non lo è si rimette ad aspettare e un'altro prova e
così via finchè non ne arriva uno con il ticket giusto.
Nota però che se il tipo con il ticket 1 non arriva mai (perché ha lasciato
la macchina aperta e gli stanno fregando l'autoradio) tutti gli altri
clienti rimarranno in attessa all'infinito. In questo caso non si tratta
però di un deadlock. Il problema lo risolvi facendo in modo che non passi
mai più di un certo lasso di tempo senza che il numero del ticket cambi
(magari con un timer).
Ciao, Rick.

mai piů di un certo lasso di tempo senza che il numero del ticket cambi
