Problema synchronized e thread

[saso_03]

Buongiorno a tutti, chiedo aiuto su un esercizio complicato per quanto riguarda la sincronizzazione.
Spiego meglio il mio problema descrivendolo.

Un sueprmercato dispone di 3 addetti e 3 casse. Per oni cassa non sono ammesse file con più di 5 clienti. Accade spesso che un addetto debba allontanarsi dalla cassa per assistere un cliente durante la spesa ed in tal caso i clienti già in fila vengano accodati in modo ordinato nelle altre casse, dando priorità alle casse più vicine, purchè le nuove file non superino la massima lunghezza consentita.

I clienti aspetteranno, e successivamente si accoderanno in modo casuale, qualora tutte le file siano già composte da 5 clienti.

Io ho pensato di usare la politica del produttore consumatore, quindi, ho creato una classe cliente(thread), addetto(thread), supermercato(risorsa condivisa) e una classe cassa dove sono presenti solo 2 variabili una int coda e una boolean stato cassa chiusa/aperta per creare un array ad oggetti nella classe supermercato.

Posto il codice supermercato, essendo che nel cliente abbiamo un metodo paga() e nell'addetto un metodo incassa(), quindi il cliente incrementa una variabile e l'addetto decrementa tale variabile.

codice classe supermercato:

//Classe Supermercato condivisa tra tutti i thread clienti e addetti

public class Supermercato {
	
	static int MAX_CASSE;//indica il numero massimo di casse disponibili
	private int MAX_CODA;//indica la coda massima di ongni singola coda
	private Cassa casse[]; //creo un array di tipo Cassa
	
//----------------------------------------------------COSTRUTTORE----------------------------------
	public Supermercato(){
		
		MAX_CASSE=3;//inizializzazione max_casse
		MAX_CODA=5;//inizializzaziond max_coda
		casse = new Cassa[MAX_CASSE];//inizializzo l'array formato da 3 celle
		//inizializzazione casse tramite costruttore
		for(int i=0; i<casse.length; i++){
			casse[i] = new Cassa(0, true, "Cassa"+i);//inizializzo a zero la coda poi a true(aperta) la cassa e gli passo un nome
			
		}//fine for 
		
	}//fine costruttore
	
	
	
//------------------------------------------------------METODI---------------------------------------
	
//questo metodo permette la scelta della cassa migliore, quindi con minor numero di clienti in coda-----------------------------
	public String scegliCassa() {

		if( casse[0].get_coda() <= casse[1].get_coda() ){
			
			if( casse[0].get_coda() <= casse[2].get_coda() ){
				return casse[0].get_nome();
			}else
				return casse[2].get_nome();
			
		}else if(casse[1].get_coda() <= casse[2].get_coda() ){
			
			return casse[1].get_nome();
		}else 
			return casse[2].get_nome();
		
	     
	}//fine metodo scegliCassa

	
	
	
//questo metodo aggiunge un cliente alla coda, incrementando l'opportuna variabile--------------------------------------
	public synchronized void paga(){
		
		System.out.println("Il " + Thread.currentThread().getName() + " è entrato nel supermercato.");
		System.out.printf("la funzone sceltaCassa ha scelto la %s\n", scegliCassa());
		
		String cassaScelta = scegliCassa();
		
		for(int i=0; i<casse.length; i++){
			
			System.out.printf("entro nel ciclo: %d\n",i);
			//se il nome della cassa(i) è uguale al nome ritornato dal metodo scegliCassa, la coda è minore di 5, 
			// e lo stato della cassa è true(aperta) il thread si mette in coda nella cassa con minor numero di clienti(thread)
			if( casse[i].get_nome().equals(cassaScelta) && (casse[i].get_coda()<MAX_CODA) && (casse[i].get_statoCassa()==true) ){
				System.out.println("Il " + Thread.currentThread().getName() + " si mette in coda nella " + casse[i].get_nome());
				notify();//mando un signal di risveglio
				casse[i].set_coda("i");//incrementa la coda
				System.out.printf("Adesso la coda è di %d\n", casse[i].get_coda());
				break;
			}else{//altrimenti essendo che le code delle casse sono tutte piene 
				try {
					wait();//il cliente si fa una passeggiata(entra in waiting) aspettando che si liberi una delle code.
				} catch (InterruptedException e) {
					
					e.printStackTrace();
				}//fine catch
			}//fine else
			
			System.out.printf("ciclo n: %d\n",i);
		}//fine for

	}//fine metodo paga
	
	
	
	
	public synchronized void incassa(){
		
		
	}//fine metodo incassa
	
}//fine classe supermercato

l'output che viene fuori da questo primo codice è il seguente:

Il Cliente9 è entrato nel supermercato.
la funzone sceltaCassa ha scelto la Cassa0
entro nel ciclo: 0
Il Cliente9 si mette in coda nella Cassa0
Adesso la coda è di 1
Il Cliente9 ha pagato e sta uscendo.
Il Cliente2 è entrato nel supermercato.
la funzone sceltaCassa ha scelto la Cassa1
entro nel ciclo: 0
Addetto3 ha passato i prodotti e incassato.
Il Cliente7 è entrato nel supermercato.
la funzone sceltaCassa ha scelto la Cassa1
entro nel ciclo: 0
Addetto1 ha passato i prodotti e incassato.
Il Cliente1 è entrato nel supermercato.
la funzone sceltaCassa ha scelto la Cassa1
entro nel ciclo: 0
Il Cliente10 è entrato nel supermercato.

Non appena il programma parte, i primi 6 passi sono corretti.
come è possibile che il thread(cliente2) è entrato nella sezione critica neanche il tempo di eseguire il ciclo for entra un altro thread(Cliente7)? non dovrebbe mantenere il look fino a quando non ha finito di eseguire tutte le istruzioni presenti all'interno del metodo paga()?

Poi, la politica che sto utilizzando vi sembra una politica buona? avete piccoli ma grandi consigli?
Cosa sbaglio?



Grazie in anticipo...spero in un vostro aiuto...

[LeleFT]

Il codice va postato usando gli appositi tag CODE, altrimenti risulta praticamente un'accozzaglia illeggibile, mancando di formattazione ed indentazione.

Non è difficile: si scrive
[CODE]

poi si incolla il codice

poi si scrive
[/CODE]


Sistemo io.


Ciao.

[saso_03]

ah scusa, grazie per la sistemazione ;-)
potresti aiutarmi con il problema che ho?

[LeleFT]

Non ho controllato il codice da te postato perchè manca la parte in cui istanzi i vari oggetti e fai partire i thread. Bisogna vedere lì come sono state fatte le cose.

Puoi postare anche quel codice?


Ciao.

[saso_03]

Almeno la politica che sto utilizzando è corretta?

public class Main {

	public static void main(String args[]){
		
		Supermercato s = new Supermercato();
		Addetto a;
		Cliente c;
		
		//creo 3 addetti
		for(int i=1; i<=3; i++){
			a = new Addetto(s, "Addetto"+i);
			a.start();
			
		}//fine for
		
		//creo 10 clienti
		for(int x=1; x<=10; x++){
			c = new Cliente(s, "Cliente"+x);
			c.start();
		}//fine for
		
	}//fine metodo main
	
}//fine classe main

[saso_03]

Per ulteriori chiarimenti posto pure le altre classi...


classe ADDETTO:

//Creo un thread di tipo Addetto
public class Addetto extends Thread {

	private Supermercato s;//risorsa condivisa.
	
	public Addetto(Supermercato market, String nome){
		
		super ( nome ); //inizializzo il nome del thread.
		s = market;//izializzo la variabile privata con la risorsa condivisa tra thread.
		
	}//fine costruttore
	
	public void run(){
		
		while( true ){
			
			//simuliamo l'addetto nel passare i prodotti
			try {
				s.incassa();
				Thread.sleep((int) (Math.random() * 3001));//la simulazione ha un tempo che va da 0 a 3 secondi
				
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}
			//adesso l'addetto è pronto a incassare
			
			System.err.println( Thread.currentThread().getName() + " ha passato i prodotti e incassato." );
			
		}
	}//fine metodo run
	
}//fine classe Addetto

classe CLIENTE:

//Creo un Thread di tipo Cliente

public class Cliente extends Thread {

	private Supermercato s; //risorsa condivisa.
	
	public Cliente(Supermercato market, String nome){
		
		super ( nome ); //inizializzo il nome del thread.
		s = market;//izializzo la variabile privata con la risorsa condivisa tra thread.
		
	}//fine costruttore
	
	
	public void run(){
		
		
		//una volta creato il thread cliente, simuliamo l'entrata al supermercato e scelta dei prodotti.
		try {
			Thread.sleep((int) (Math.random() * 5001));//mettiamo un tempo random da 0 a 6 secondi per la simulazione entrata e scelta.
			s.paga();
		} catch (InterruptedException e) {
			
			e.printStackTrace();
		}
		
		//adesso si dirige per andare a pagare e uscire dal supermercato
		
		
		System.out.println("Il " + Thread.currentThread().getName() + " ha pagato e sta uscendo.");
		
	}//fine metodo run
	
}//fine classe Cliente

classe CASSA:

//Creo una classa cassa, sarà la risorsa condivesa tra i thread cliente e addetto.
public class Cassa {
	
	private String nome;//nome di ogni cassa
	private int coda; //variabile che viene incrementata dai clienti che si mettono in coda, decrementata dagli addetti.
	private boolean statoCassa;//stato della cassa true(aperta) false(chiusa)  
	
	
//----------------------------------------------------COSTRUTTORI----------------------------------
	public Cassa(){
		coda = 0; //inizializziamo la coda a zero - nessun cliente in coda
		statoCassa = true;//inizializziamo la cassa a true - cassa aperta i clienti possono accodarsi
		nome = "NULL";//inizializza il nome della cassa a null
	}//fine costruttore senza parametri
	
	
	public Cassa(int c, boolean state, String nom){
		coda = c; //inizializziamo la coda tramite parametro
		statoCassa = state;//inizializziamo la cassa tramite parametro
		nome = nom;//inizializza il nome della cassa tramite parametro
		
	}//fine costruttore con parametri
	
	
	
//------------------------------------------------------METODI---------------------------------
//metodi per settare le variabili private della classe cassa---------------------------------
	public void set_coda(String cod){
		if(cod.equals("i")){
			coda++;
		}else if(cod.equals("d"))
			coda--;
		
	}//fine metodo set coda 
	
	public void set_statoCassa(boolean statoC){
		statoCassa = statoC;
	}//fine metodo set_statoCassa
	
	public void set_nome(String neme){
		nome = neme;
	}//fine metodo set nome 
	
	
//metodi di ritorno per le variabili private della classe cassa-----------------------
	public int get_coda(){
		return coda;
	}//fine metodo get coda
	
	public boolean get_statoCassa(){
		return statoCassa;
	}//fine metodo get stato cassa
	
	public String get_nome(){
		return nome;
	}//fine metodo get nome
	
}//fine classe cassa

[LeleFT]

Ci sono alcune cose da sistemare.
Innanzitutto, il metodo wait() funziona in coppia coi metodi notify()/notifyAll(), che tu non richiami da nessuna parte all'interno del supermercato. Non credo che, allo stato attuale, questo comporti grossi problemi poichè hai 3 casse e ciascuna può ospitare 5 clienti... per un totale di 15 clienti prima di mandare a spasso un cliente. Tu di clienti ne crei 10 quindi non ti metti mai in quella situazione. Ma la cosa va ponderata lo stesso, almeno per coerenza: se un thread finisce in wait() come lo risvegli se non richiami un notify() ?

Come funziona la sincronizzazione con wait(): il thread che va in wait() deve farlo all'interno di un ciclo. Il ciclo deve avere come condizione di uscita la possibilità di lavoro da parte del thread (mi spiego: il thread deve entrare nel ciclo, e finire in wait(), SOLO se il suo lavoro non può essere fatto; al contrario, il thread deve uscire dal ciclo o non entrarci per nulla se è al primo test). Questo perchè non puoi sapere a priori quale degli N thread bloccati verrà risvegliato, né per quale motivo questo venga risvegliato. La cosa certa è che, se un thread era in wait() e viene risvegliato, deve prima di tutto verificare di poter effettivamente continuare il proprio lavoro. In caso contrario, deve essere rimesso in wait(). Questa è la struttura:

while ( !possoLavorare() ) {
   // Finchè non potrò lavorare, mi metto in wait
   try { wait(); } catch (InterruptedException ie) { }
}

Se il thread è in wait() e viene risvegliato, la prima cosa che farà saà controllare nuovamente se può lavorare o meno. In caso negativo, tornerà in wait().

Poi veniamo al controllo delle code alle casse: il controllo sulla possibilità di mettersi in coda oppure andare a spasso è la primissima cosa che il metodo dovrebbe fare. Quindi, per prima cosa devi effettuare un controllo sulle casse "libere". Se non ve ne sono, il cliente deve essere messo in wait() subito. Solo dopo aver passato questo controllo, procederà con le normali operazioni (qui, non ho capito perchè il metodo incassa() sia vuoto: l'addetto che lo richiama dovrebbe incassare dal primo cliente in coda e, di conseguenza, diminuire il numero di clienti in coda presso quella cassa e notificare che c'è un posto libero).

Poi attenzione: nel metodo paga() richiami due volte il metodo "scegliCassa()". Non è un problema, per come è implementato, ma da una logica derivante solamente dal "mondo reale" delle casse, tale metodo andrebbe richiamato una sola volta ed il valore salvato in una variabile. Per le stampe a video si dovrebbe, quindi, utilizzare il valore della variabile, senza richiamare nuovamente il metodo.

Per il momento cerca di sistemare queste cose, perchè così come sono mi sembrano abbastanza confusionarie (sorvoliamo sulla scelta di un metodo come set_coda() della classe "Cassa", che accetta una stringa per capire se deve sommare o sottrarre... bastava passargli un booleano o, meglio, l'intero 1 o -1.


Ciao.

[saso_03]

Grazieeeeeeeeeeeeee veramente grazieeeeeeee
qualcosa è migliorato...

Questo è l'output che esce adesso:

Addetto1 aspetta...
Addetto2 aspetta...
Addetto3 aspetta...
Il Cliente18 è entrato nel supermercato.
Il Cliente18 si mette in coda nella Cassa0
Adesso la coda è di 1
Addetto1 aspetta...
Il Cliente16 è entrato nel supermercato.
Il Cliente16 si mette in coda nella Cassa1
Addetto2 aspetta...
Adesso la coda è di 1
Il Cliente1 è entrato nel supermercato.
Il Cliente1 si mette in coda nella Cassa2
Adesso la coda è di 1
Addetto3 aspetta...
Il Cliente4 è entrato nel supermercato.
Il Cliente4 si mette in coda nella Cassa0
Adesso la coda è di 2
Addetto1 sta passando i prodotti...
Il Cliente19 è entrato nel supermercato.
Il Cliente19 si mette in coda nella Cassa0
Adesso la coda è di 2
Addetto2 sta passando i prodotti...
Il Cliente8 è entrato nel supermercato.
Addetto3 aspetta...
Il Cliente8 si mette in coda nella Cassa1
Adesso la coda è di 1
Il Cliente16 è entrato nel supermercato.
Il Cliente16 si mette in coda nella Cassa1
Adesso la coda è di 2
Addetto3 sta passando i prodotti...
Il Cliente13 è entrato nel supermercato.
Il Cliente13 si mette in coda nella Cassa2
Adesso la coda è di 1
Il Cliente18 è entrato nel supermercato.
Il Cliente18 si mette in coda nella Cassa2
Adesso la coda è di 2
Il Cliente19 è entrato nel supermercato.
Il Cliente19 si mette in coda nella Cassa0
Adesso la coda è di 3
Il Cliente7 è entrato nel supermercato.
Il Cliente7 si mette in coda nella Cassa1
Adesso la coda è di 3
Il Cliente20 è entrato nel supermercato.
Il Cliente20 si mette in coda nella Cassa2
Adesso la coda è di 3
Il Cliente17 è entrato nel supermercato.
Il Cliente17 si mette in coda nella Cassa0
Adesso la coda è di 4
Il Cliente8 è entrato nel supermercato.
Il Cliente8 si mette in coda nella Cassa1
Adesso la coda è di 4
Addetto2 ha passato i prodotti e incassato.
Addetto2 sta passando i prodotti...
Il Cliente12 è entrato nel supermercato.
Il Cliente12 si mette in coda nella Cassa1
Adesso la coda è di 4
Il Cliente19 è entrato nel supermercato.
Il Cliente19 si mette in coda nella Cassa2
Adesso la coda è di 4
Il Cliente5 è entrato nel supermercato.
Il Cliente5 si mette in coda nella Cassa0
Adesso la coda è di 5
Il Cliente3 è entrato nel supermercato.
Il Cliente3 si mette in coda nella Cassa1
Adesso la coda è di 5
Il Cliente20 è entrato nel supermercato.
Il Cliente20 si mette in coda nella Cassa2
Adesso la coda è di 5
Il Cliente9 ha notato che tutte le code sono piene, quindi, attende...
Il Cliente10 ha notato che tutte le code sono piene, quindi, attende...
Addetto2 ha passato i prodotti e incassato.
Addetto2 sta passando i prodotti...
Addetto1 ha passato i prodotti e incassato.
Addetto1 sta passando i prodotti...
Il Cliente6 è entrato nel supermercato.
Il Cliente6 si mette in coda nella Cassa0
Adesso la coda è di 5
Il Cliente9 è entrato nel supermercato.
Il Cliente1 è entrato nel supermercato.
Il Cliente1 si mette in coda nella Cassa1
Adesso la coda è di 5
Il Cliente10 è entrato nel supermercato.
Il Cliente17 ha notato che tutte le code sono piene, quindi, attende...
Il Cliente3 ha notato che tutte le code sono piene, quindi, attende...
Il Cliente5 ha notato che tutte le code sono piene, quindi, attende...
Il Cliente13 ha notato che tutte le code sono piene, quindi, attende...
Il Cliente15 ha notato che tutte le code sono piene, quindi, attende...
Il Cliente2 ha notato che tutte le code sono piene, quindi, attende...
Il Cliente7 ha notato che tutte le code sono piene, quindi, attende...
Addetto3 ha passato i prodotti e incassato.
Il Cliente11 ha notato che tutte le code sono piene, quindi, attende...
Addetto3 sta passando i prodotti...
Il Cliente14 è entrato nel supermercato.
Il Cliente14 si mette in coda nella Cassa2
Adesso la coda è di 5
Il Cliente17 è entrato nel supermercato.
Il Cliente18 ha notato che tutte le code sono piene, quindi, attende...
Il Cliente17 ha notato che tutte le code sono piene, quindi, attende...
Il Cliente20 ha notato che tutte le code sono piene, quindi, attende...
Il Cliente14 ha notato che tutte le code sono piene, quindi, attende...
Addetto3 ha passato i prodotti e incassato.
Addetto3 sta passando i prodotti...

Noto che qualcosa non funzioni ancora bene...o sbaglio? penso sia il nuovo metodo incassa()

Questo è il codice della classe supermercato mettendo il controllo subito nel metodo paga(),
ho aggiornato il metodo incassa()

//Classe Supermercato condivisa tra tutti i thread clienti e addetti

public class Supermercato {
	
	static int MAX_CASSE;//indica il numero massimo di casse disponibili
	private int MAX_CODA;//indica la coda massima di ongni singola coda
	private int MIN_CODA; //varibile dove il metodo scegliCassa inserisce il numero minore di clienti tra tutte le code
	private Cassa casse[]; //creo un array di tipo Cassa
	

	
	//----------------------------------------------------COSTRUTTORE---------------------------------------------------------------
	public Supermercato(){
		
		MAX_CASSE=3;//inizializzazione max_casse
		MIN_CODA=0;//inizializzo la min_coda
		MAX_CODA=5;//inizializzaziond max_coda
		casse = new Cassa[MAX_CASSE];//inizializzo l'array formato da 3 celle
		//inizializzazione casse tramite costruttore
		for(int i=0; i<casse.length; i++){
			casse[i] = new Cassa(0, true, "Cassa"+i);//inizializzo a zero la coda poi a true la cassa e gli passo un nome
			
		}//fine for 
		
	}//fine costruttore
	
	
	
	//------------------------------------------------------METODI------------------------------------------------------------------
	
	//questo metodo permette la scelta della cassa migliore, quindi con minor numero di clienti in coda-----------------------------
	public String scegliCassa() {

		if( casse[0].get_coda() <= casse[1].get_coda() ){
			
			if( casse[0].get_coda() <= casse[2].get_coda() ){
				
				MIN_CODA = casse[0].get_coda();
				return casse[0].get_nome();
				
			}else{
				MIN_CODA = casse[2].get_coda();
				return casse[2].get_nome();
			}//fine else interno		
			
		}else if(casse[1].get_coda() <= casse[2].get_coda() ){
			MIN_CODA = casse[1].get_coda();
			return casse[1].get_nome();
		}else{
			MIN_CODA = casse[2].get_coda();
			return casse[2].get_nome();
		}//fine else esterno
	     
	}//fine metodo scegliCassa

	
	
	
	//questo metodo aggiunge un cliente alla coda, incrementando l'opportuna variabile--------------------------------------
	public synchronized void paga(){
		
		String cassaScelta = scegliCassa();
		
		//Controlla subito se tutte le code sono piene, il cliente deve essere messo in wait() subito
		while ( MIN_CODA == 5) {
			   // Finchè le code sono tutte piene, mi metto in wait
			
			System.out.println("Il " + Thread.currentThread().getName() + " ha notato che tutte le code sono piene, quindi, attende...");
			   try { 
				   
				   wait(); 
			   } catch (InterruptedException e) {
				   e.printStackTrace();
			   }//fine catch
			}//fine while
		
		System.out.println("Il " + Thread.currentThread().getName() + " è entrato nel supermercato.");
		//System.out.printf("la funzone sceltaCassa ha scelto la %s\n", cassaScelta);
		
		
		
		for(int i=0; i<casse.length; i++){
			
			//System.out.printf("entro nel ciclo: %d\n",i);
			//se il nome della cassa(i) è uguale al nome ritornato dal metodo scegliCassa, la coda è minore di 5, 
			// e lo stato della cassa è true(aperta) il thread si mette in coda nella cassa con minor numero di clienti(thread)
			if( casse[i].get_nome().equals(cassaScelta) && (casse[i].get_coda()<MAX_CODA) && (casse[i].get_statoCassa()==true) ){
				System.out.println("Il " + Thread.currentThread().getName() + " si mette in coda nella " + casse[i].get_nome());
				notify();//mando un signal di risveglio agli addetti
				casse[i].set_coda(1);//incrementa la coda
				System.out.printf("Adesso la coda è di %d\n", casse[i].get_coda());
				break;
			}//fine if
			//System.out.printf("ciclo n: %d\n",i);
		}//fine for

	}//fine metodo paga
	
	
	
	
	//questo metodo elimina un cliente dlla coda, decrementando l'opportuna variabile--------------------------------------
	public synchronized void incassa(){
		
		String cassaScelta = scegliCassa();
		
		//finchè tutte le casse sono vuote l'addetto si mette in waitng aspettando un cliente che manda un signal di notify
		while(MIN_CODA == 0){
			
			System.err.println(Thread.currentThread().getName() + " aspetta...");
			
			try {
					wait();
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}//fine catch
			
		}//fine while
		
		//il thread(addetto) che entra in questa sezione decrementa la propria coda.
		if(Thread.currentThread().getName().equals("Addetto1") && casse[0].get_coda() > 0){
			
			System.err.println(Thread.currentThread().getName() + " sta passando i prodotti...");
			casse[0].set_coda(-1);
			
		}else if(Thread.currentThread().getName().equals("Addetto2") && casse[1].get_coda() > 0){
			
			System.err.println(Thread.currentThread().getName() + " sta passando i prodotti...");
			casse[1].set_coda(-1);
			
		}else if(Thread.currentThread().getName().equals("Addetto3") && casse[2].get_coda() > 0){
			
			System.err.println(Thread.currentThread().getName() + " sta passando i prodotti...");
			casse[2].set_coda(-1);
			
		}else{
			
			System.err.println(Thread.currentThread().getName() + " aspetta...");
			
			try {
					//Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
					wait();
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}//fine catch
			
		}//fine else
			

		
	}//fine metodo incassa
	
}//fine classe supermercato

[saso_03]

Aiutooooo per favoreeeee non riesco a fare questo benedetto esercizio :-(