[JAVA] Dubbio su synchronized

[Manugal]

Ciao a tutti!

Ho una LinkedHashMap<String,boolean[]> dove il primo parametro rappresenta l'orario di uno spettacolo e il secondo rappresenta un array di booleani la cui lunghezza è data dai posti totali nella sala. Un elemento dell'array è settato a true se il posto è libero, altrimenti è settato a false. Questa struttura dati (che ho reso public) è situata in una classe che funge da Server multithreaded.

Il client che si connetterà per prenotare i posti dovrà accedere a tale struttura dati. Visto che si tratta di un applicazione multithreaded ci potrebbero essere più client che accedono.

A me serve implementare qualcosa che gestisca l'accesso mutuamente esclusivo a tale mappa, facendo in modo però che se un client prenota un posto per le 14:00 e un altro client prenota un posto per le 16:00, l'operazione deve avvenire simultaneamente.

Io ho implementato una cosa simile, ma già so che non funziona

// disp è la LinkedHashMap descritta prima

private boolean prenotazione(int sala, String orario, String posti) {
		int i;
		Sala s = ServerCinema.getSala(sala);
		boolean[] seats = s.disp.get(orario);
		String[] p = posti.split("-");
		synchronized(seats){
			if(p.length > freeSeats(seats))  //controlla se ci sono posti liberi a sufficienza
				return false;
			for(i=0; i<p.length; ++i){
				int num = Integer.parseInt(p[i]);
				if(seats[num])
					seats[num]=false;
			}
			s.disp.put(orario, seats);
		}
		return true;
	}

Non saprei come fare, perché se imposto synchronized(disp) poi non potrò entrare più con altri client che vogliono prenotare per un ora diversa. Come potrei fare?

Grazie.

[Furla]

ciao, io non amo il java ma all'università ce lo hanno fatto usare per il multitasking...
noi dichiaravamo synchronized tutta la funzione che gestiva la struttura da usare in mutua esclusione. ovviamente tale struttura è privata in modo che vi si possa accedere solo tramite la suddetta funzione. usando opportunamente questo sistema puoi anche fare in modo che la mutua esclusione entri in gioco solo quando più prenotazioni agiscono sullo stesso spettacolo (che a quanto ho capito è il tuo obiettivo).

l'array di booleani va quindi messo in una classe apposita da usare in mutua, e ad ogni orario corrisponde un oggetto di quel tipo.

non so se si possa fare con la LinkedHashMap, ma mi sembra già un tipo inadeguato visto che ti costringe a farti una copia di tutto l'array, modificarlo e sovrascriverlo. purtroppo come ti ho detto non conosco java, ma se esiste ti suggerisco di usare un qualche altro tipo di array associativo.

[Furla]

sry doppio post

[Manugal]

Grazie per la risposta. Piano piano sto pensando a una soluzione. In pratica creo una nuova classe Orario (costituita dall'orario e dall'array di booleani) per poi gestire la mutua esclusione direttamente su di essa. Credo che funzioni.

[Furla]

sì però nel tuo codice l'orario viene usato come indice associativo, se non ho capito male, nella LinkedHashMap. quindi devi trovare il modo di raccogliere i vari oggetti di quella classe e di accedere ad uno o all'altro a seconda dell'orario, per arrivare ad una cosa di questo tipo:

sala[numSala].spettacoli[orario].occupa(numposto)

inoltre nel metodo occupa dovresti preoccuparti di verificare che il posto passato per parametro non sia già prenotato o fuori range, in caso contrario restituire false o lanciare un'eccezione (io odio le eccezioni, poi fai tu )


il tuo codice non funziona perché se non sbaglio tu modifichi l'oggetto "s" di tipo sala che è solo una copia locale del dato sul server, e che muore al termine dell'istanza della funzione.

[Manugal]

 sala[numSala].spettacoli[orario].occupa(numposto)

E' proprio quello a cui aspiro ad arrivare

Per farlo infatti non uso più una LinkedHashMap ma un semplice array di Orari. Quindi, quando sarà il momento, mi "sincronizzerò" su un particolare orario[i]. L'unica cosa è che quando entro nel metodo prenotazione() io richiedo lo stesso una copia della Sala tramite Sala s = ServerCinema.getSala(sala); (altrimenti non so come accederci) . E' qua il problema, perché visto che ogni volta mi da una copia diversa, se due client entrano richiedono due copie che sono diverse e quindi il lock non funzionerà giusto? Quindi è qui che ora non saprei come far sì che se uno entra in una sala avrà sempre una e un'unica copia.

Spero di essermi spiegato.

[Furla]

no il problema è molto più grave: con s.disp.put(orario, seats); tu modifichi la copia della sala, non quella "originale": quindi la funzione è inutile perché lascia invariato l'oggetto sala "originale".

non capisco perché ti vuoi creare un copia della sala. io farei una cosa di questo genere:

class posti{
  private boolean[] b;
  private int num;

  sala(int n)  //costruttore
    {num=n; b=boolean[n];} //se non sbaglio viene inizializzato tutto a false, poniamo che false significhi "non prenotato"
   boolean synchronized prenota(int n)
  {
    if (b[n]==true || n>=num) return false;
    return b[n]=true;
  }
}

a questo punto usi un array associativo di posti, ciascuno dei quali è associato ad un orario.

[Manugal]

Ok, ora credo di aver capito come risolvere il problema. Io ho, sul server, due classi. Una è ServerCinema che crea solamente una piccola interfaccia grafica e accetta nuove connessioni dai client. L'altra è ServerHandler (che estende Thread) che è quella che gestisce le connessioni dei client lanciando un thread separato per ognuna di esse. E' dentro ServerHandler che io creo la copia locale di una sala, mentre io dovrei leggere direttamente le sale "originali" create in ServerCinema. Allora stavo pensando che invece di avere questa dichiarazione:

 class ServerHandler extends Thread

Potevo fare una cosa del genere:

 class ServerHandler extends ServerCinema implements Runnable

In questo modo rendo protected il membro Sala[] così posso accederci direttamente senza crearmi una copia locale. Il problema è il seguente. Nel costruttore di ServerCinema ho il seguente codice adesso:

ServerCinema(){
		createServerFrame();  //crea l'interfaccia grafica del Server
		try {
			prog = new RandomAccessFile("src/programmazione.txt","r");
			for(int i=0; i<6; ++i){
				plots = new FileInputStream("src/trama" + (i+1) + ".rtf");
				sale[i] = new Sala();
				sale[i].fillSala(prog,plots);
			}
			prog.close();
			plots.close();
			textAreaS.append("*** Server in ascolto... ***\n");
			server = new ServerSocket(2000);
			while(true) {
				client = server.accept();
				textAreaS.append("Sto accettando una connessione da " + client.getInetAddress() + "\n");
				Runnable handler = new ServerHandler(client);
				new Thread(handler).start(); 
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

Il problema sono le due righe:

 
Runnable handler = new ServerHandler(client);  // il costruttore di ServerHandler non fa altro che collegare un InputStream e un OutputStream con il Socket client
new Thread(handler).start();

In pratica io avvio il Server e mi si apre l'interfaccia grafica normalmente, però non appena un client tenta una connessione con il server, mi si apre una nuova interfaccia grafica del Server (questa penso sia dovuto a causa dell'istruzione new Thread(handler).start();. Io praticamente non voglio che alla connessione del client al server, mi si crei una nuova interfaccia grafica del Server.

Spero di essere stato chiaro.

Grazie.

P.S. : ServerHandler è la classe che ha la famosa funzione synchronized prenotazione()

[Manugal]

Forse ho risolto. Spostano la createServerFrame() (cioè la funzione che crea l'interfaccia grafica) nel main, quando creo un nuovo thread con quell'istruzione non mi crea più l'interfaccia nuova, ma mi usa quella preesistente. Mi potreste spiegare perché? (Sempre se c'è una spiegazione )