JAVA - esercizio sui thread

[uranya]

Per favore datemi una mano con questo esercizio è l'ennesima volta che riprovo a farlo senza successo.
Ho bisogno di una implementazione completa perchè ho difficoltà con la sintassi di java e perciò molto probabilmente non sarei in grado di tradurre eventuale pseudocodice in linee di codice. Grazie infinite:

Corstuire un programma in linguaggio java che, attraverso l’uso dei thread e della mutua esclusione, realizza il gioco Occupa-Sedia. Il gioco consiste nell’avere un certo numero K di sedie ed un numero N di persone con N>K ed un arbitro. Quando l’arbitro da il via le N persone partono contemporaneamente da una stessa posizione e cercano di occupare una sedia. Dopo ogni sessione del gioco, solo le K persone che sono riuscite a sedersi ricevono un punto.
In pratica, occorre definire una classe Sedia per modellare un oggetto sedia che può trovarsi in due possibili stati: libera o occupata. I metodi di tale classe devono consentire di rilevare lo stato della sedia, di occuparla e di conoscere il nome dell’eventuale occupante. Occorre inoltre definire una classe Occupa-Sedia con attributi per rappresentare il numero di partecipanti, il numero di sedie disponibili ed il numero di sessioni previste per una determinata istanza del gioco. Occorre definire una struttura dati per modellare la sequenza di K sedie disponibili ed una per modellare gli N partecipanti al gioco. Sia le sedie che le persone devono essere identificabili tramite un nome (si può usare anche un sequenziale sedia1, sedia2, …, persona1, persona2,…).
Il metodo main dovrà creare un’istanza del gioco, chiedendo all’utente di fornire in input i parametri della stessa (N, K ed il numero di sessioni) ed avviare il gioco. Il tentativo da parte delle N persone di occupare ciascuno una sedia dovrà essere modellato tramite N Thread e tutti dovranno (in teoria) essere avviati “contemporaneamente” (suggerimento: si potrebbero usare wait e NotifyAll). L’accesso dei thread alla struttura dati che modella la sequenza di sedie dovrà essere gestito in modo mutuamente esclusivo, attraverso l’uso di meccanismi di sincronizzazione.
Il risultato finale dovrà consistere nella stampa dei risultati delle varie sessioni di un’istanza del gioco (indicando da chi è occupata ciascuna sedia) unitamente alla classifica finale con i punteggi riportati da ciascuna persona (numero di volte in cui è riuscito a sedersi).

[ivenuti]

ciao,

non avercela a male, ma non credo ti sia utile una soluzione "pappa pronta"; e te lo dico per il tuo bene (leggi: altrimenti non impareresti!).

TI consiglio di provare a cercare una soluzione e a postare qui solo i punti "critici", ovvero dei dubbi mirati che ti impediscono di procedere oltre. In questo modo l'esercizio ti sarà davvero utile e imparerai qualcosa di nuovo.

In bocca al lupo

[uranya]

se hai la pazienza di leggere il mio codice, a dire la verità ne ho una decina di versioni (purtroppo non funzionanti). Ti posto l'ultima...non credevo fosse la strada più semplice per chi può aiutarmi (purtroppo non so individuare dove sono i punti critici ). Grazie della disponibilità.

public class Partecipante implements Runnable{
public Partecipante(String nome)
{
this.nome=nome;
this.punteggio=0;

}

public void aumentaPunteggio()
{
this.punteggio++;
}

public int getPunteggio()
{
return this.punteggio;
}

public String getNome()
{
return this.nome;
}
//il metodo che deve essere sovrascritto
public void run()
{ int nPart=Test.numPartecipanti;
try{
wait();
for(int i=0;i<nPart;i++)
{
Sedie[i].occupaSedia(this);
}

}
catch(InterruptedException e)
{ return; }
}

public String nome;
public int punteggio;
}

public class Sedia {
public Sedia()
{
this.occupata=false;
this.occupante=new Partecipante(String nomePartecipante);
}
public boolean getStatoSedia()
{
return this.occupata;
}
public synchronized void occupaSedia(Partecipante occupante)
{
if((numeroSedie>0)&&(!this.occupata))
{
numeroSedie--;
this.occupata=true;
this.occupante=occupante;
System.out.println("Il giocatore"+occupante.getNome()+"ha occupato una Sedia");
occupante.aumentaPunteggio();
System.out.println("ha il seguente punteggio: "+occupante.getPunteggio());
}
else
System.out.println("Non ci sono sedie da occupare");
System.out.println("il giocatore"+occupante.getNome()+"è rimasto in piedi");
}
public void liberaSedia()
{
this.occupata=false;
}
public String getNomeOccupante()
{
return this.occupante.getNome();
}
public boolean occupata;
public Partecipante occupante;
static int numeroSedie=Test.numSedie;
}

import java.io.*;

public class Test {

public static void main(String[] args)throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Inserisci un istanza del gioco - N. Sedie, N. Partecipanti, N. Sessioni: ");

String scelta=br.readLine();
numSedie=Integer.parseInt(scelta);

String scelta2=br.readLine();
numPartecipanti=Integer.parseInt(scelta2);

String scelta3=br.readLine();
numSessioni=Integer.parseInt(scelta3);

System.out.println("n. sedie:"+numSedie+" n. Partecipanti:"+numPartecipanti+" n. Sessioni:"+numSessioni);

//inizializzo le sedie
Sedia[] sedie=new Sedia[numSedie];
for(int i=0;i<numSedie;i++)
sedie[i]=new Sedia();

//inizializzo i partecipanti
Partecipante[] partecipanti= new Partecipante[numPartecipanti];
for(int i=0;i<numPartecipanti;i++)
Thread partecipanti[i]= new Partecipante("partecipante"+i);

for(int i=0;i<=numSessioni;i++)
{
new Thread(partecipanti[i]).start();
sedie[i].liberaSedia();
partecipanti.notifyAll();
//join();
}
//System.out.println("Statistica:");
//for(int i=0;i<=numPartecipanti;i++)
// System.out.println("Il giocatore ");

}

public static int numPartecipanti;
public static int numSedie;
public static int numSessioni;
}

[simo7784]

C'e' un po' di confusione sui thread. Spezzo la risp su piu' post per migliorare la leggibilita'.
Partiamo dall'inizio...

In pratica, occorre definire una classe Sedia per modellare un oggetto sedia che può trovarsi in due possibili stati: libera o occupata. I metodi di tale classe devono consentire di rilevare lo stato della sedia, di occuparla e di conoscere il nome dell’eventuale occupante.

Quindi

public class Sedia {
   private String Nome; //Anche le sedie hanno un nome
   private boolean occupata; //Memorizza lo stato
   private Partecipante occupante; //Memorizza chi la occupa

   public Sedia(String nome) {
      this.nome=nome;
      this.occupata=false;
      this.occupante=null;
       /*
        * All'inizio la sedia e' libera. Non ha senso creare un ulteriore partecipante 
        * ed assegnarlo alla variabile occupante.
        */
   }

   public boolean getStatoSedia() {
      return this.occupata;
   }

   public String getNome(){...}
   
   public Partecipante getOccupante() {...}

   public void reset(){...}
   //per comodita' setta occupata a false e occupante a null. Lo chiami dopo ogni sessione.
   

   public void occupa() {
      this.occupata = true;
   }

}

Sedia finisce quà perche' rappresenta un unica sedia. I metodi sincronizzati stanno da un'altra parte.

[simo7784]

Occorre inoltre definire una classe Occupa-Sedia con attributi per rappresentare il numero di partecipanti, il numero di sedie disponibili ed il numero di sessioni previste per una determinata istanza del gioco. Occorre definire una struttura dati per modellare la sequenza di K sedie disponibili ed una per modellare gli N partecipanti al gioco.

Quindi (La classe che manca nel tuo codice)

public class OccupaSedia {
   private int numPartecipanti;
   private int numSedie;
   private int numSessioni;

   private Partecipante[] partecipanti;
   private Sedie[] sedie; //Io sinceramente non userei un array, comunque fai tu.

   public OccupaSedia(int numPartecipanti, int numSedie, int numSessioni){
      /* Setti le variabili
       * crei gli array e li popoli di elementi
       * puoi anche far partire i thread già che ci sei
       */
   }
   
   public void avviaSessione() {
       partecipanti.notifyAll();
   }
   
   public synchronized boolean occupaSedia() {
      Sedia sedia = null;
      for(int i=0; i<numSedie; i++) {
         sedia = sedie[i];
         //Se la sedia non e' occupata, la occupo ed esco dal for
         if(!sedia.getStatoSedia) {
            sedia.occupa();
            return true;
          }
      }
      //Se tutte le sedie sono gia' occupate, ho perso.
      return false;
   }

   public void terminaSessione() {
      // Stampi le tue statistiche poi azzeri con il codice sotto
      for(int i=0; i<numSedie; i++) {
          sedie[i].reset();
      }
   }
}

[uranya]

Ok, grazie mille.
Quindi hai eliminato la classe Partecipante, e dove memorizzi il punteggio? Oppure manca ancora una parte?

[simo7784]

Partecipante e' ok, tranne il run. Ogni classe rappresenta un songolo partecipante, quindi non devi tentare di occupare tutte le n sedie, ma basta una.

/* Metti una variabile che punta alla classe OccupaSedie che crea il partecipante.
 * Nel costruttore istanzi la variabile.
 */
public void run() {
   try{
      wait();
      nomeVariabileChePuntaAdOccupaSedie.occupaSedia();
   }
   catch(InterruptedException e) {}
}

Poi in un altra classe (Test) ti scrivi il main che crea un oggetto occupaSedie e inizia il gioco.
Il punteggio e' memorizzato dentro ogni partecipante. Il main farebbe un for di numSessioni volte in cui chiama iniziaSessione e FineSessione. Poi in fondo, stampa i risultati totali. Magari metti in OccupaSedie un ulteriore metodo che cicle sullArray di partecipanti e per ogni partecipante stampa il punteggio.
P.s. Scusa l'edit, ma non avevo risposto all'ultima domanda.

[uranya]

Scusa ma mi sa che c'è stato un accavallamento di messaggi!!!
Anche questo riguarda i thread dopotutto stiamo avendo un accesso concorrente a questa discussione evidentemente!! Ora provo a mettere tutto insieme e ti faccio sapere.
Grazie infinite della pazienza...

[simo7784]

Un ultima cosa. (Scusa ma sono un po' sbadato).
Quando chiami occupa da partecipante, testa il valore ritornato. Se e' true, incrementa il suo punteggio. Ciao

[uranya]

ragazzi stasera il prof. ha messo la sua soluzione in rete, perciò per completezza la metto sul forum così potrebbe essere utile a qlc altro in futuro. Io cmq non è che ci ho capito molto.. :master: anche Io per legibilità dividerò le risposte...

public class Arbitro extends Partecipante {

public Arbitro(String name, Sedia[] sedie) {
super(name, sedie);
}

private synchronized void runThread() {
synchronized (sedie) {
sedie.notifyAll();
}
}

public void run() {
runThread();
}

}