[monitor] Gioco di squadra

Ci sono 4 squadre contrassegnate dai colori Rosso, Bianco, Verde, Blu, codificati con i numeri da 0 a 3. Ogni squadra è composta da numComponenti giocatori, identificati con in numeri da 0 a numComponenti-1.
Le squadre devono cercare di entrare in una porta prima delle altre seguendo le regole seguenti:

  • nessun giocatore deve entrare prima che la porta sia stata aperta dal thread principale (main) tramite l’invocazione del metodo porta.apri(). A tale scopo i thread invocano il metodo porta.attendi();
  • solo il capitano della squadra (giocatore con id 0) compete con gli altri capitani per l’accesso alla porta ( metodo porta.entra(...) );
  • quando un capitano riesce ad entrare tutti i giocatori della sua squadra possono entrare ( sempre metodo porta.entra(...) ) ma devono entrare in fila: 1,2,3, ... , numComponenti-1
  • mentre una squadra entra le altre squadre attendono. Solo quando tutta la squadra è entrata i capitani possono di nuovo competere per la porta.

L’output atteso dovrebbe essere il seguente: Tutti i giocatori vengono creati e stampano a video che sono pronti (notare che una sleep ‘mescola’ l’ordine dei giocatori). Quando la porta viene aperta, le varie squadre entrano nella porta una alla volta. Ad esempio:

La porta e' aperta!!
Componente Blu numero 0 e' entrato!
Componente Blu numero 1 e' entrato!
Componente Blu numero 2 e' entrato!
Componente Blu numero 3 e' entrato!
Componente Blu numero 4 e' entrato!
Componente Blu numero 5 e' entrato!
Componente Blu numero 6 e' entrato!
Componente Blu numero 7 e' entrato!
Componente Blu numero 8 e' entrato!
Componente Blu numero 9 e' entrato!
Componente Rosso numero 0 e' entrato!
Componente Rosso numero 1 e' entrato!
Componente Rosso numero 2 e' entrato!
Componente Rosso numero 3 e' entrato!
Componente Rosso numero 4 e' entrato!
Componente Rosso numero 5 e' entrato!
Componente Rosso numero 6 e' entrato!
Componente Rosso numero 7 e' entrato!
Componente Rosso numero 8 e' entrato!
Componente Rosso numero 9 e' entrato!
Componente Verde numero 0 e' entrato!
Componente Verde numero 1 e' entrato!
...

L’ordine dei colori varia da un’esecuzione all’altra in quanto dipende da quale capitano è più veloce.

Scopo della esercitazione è implementare il monitor ‘Porta’ con i tre metodi sopra descritti. Utilizzare il seguente programma di test:

import java.lang.Math;

public class Test extends Thread {
  private static final String colori[]={"Rosso","Bianco","Verde","Blu"}; // colori
  private static final int numColori = colori.length; // quanti colori/squadre ci sono
  private static final int numComponenti =10; // numero componenti
  private final int col, num; // colore e numero del giocatore
  private final Porta porta; // monitor utlizzato dal giocatore
  
  // costruttore: salva colore numero e monitor
  Test(int col,int num, Porta porta) {
    this.col = col;
    this.num = num;
    this.porta = porta;
  }
  
  // lancia il codice vero e proprio e cattura l'eccezione di interruzione
  public void run() {
    try {
      code();
    } catch (InterruptedException e) {
      System.out.println("Componente "+colori[col]+" numero "+num+" interrotto!!");
    }
  }
  
  // codice dei thread
  void code() throws InterruptedException {
    // evita che i thread siano gia' in fila
    sleep((int)(1000*Math.random()));
    
    // il giocatore e' pronto
    System.out.println("Componente "+colori[col]+" numero "+num+" pronto!");
    
    // attende che la porta venga aperta dal main
    porta.attendi();
    
    // cerca di entrare
    porta.entra(col,num);
    
    // attenzione che questo output non e' sincronizzato con entra.... quindi non e' detto
    // che venga stampato nell'ordine corretto. Aggiungere un blocco synchonized(porta){ } 
    // se necessario
    System.out.println("Componente "+colori[col]+" numero "+num+" e' entrato!");
    
  }
  
  public static void main(String argv []) throws InterruptedException {
    int i,j;
    
    Porta p = new Porta(numComponenti); // crea il monitor
    
    // crea i thread dei vari colori/numeri
    for (i=0; i<numColori; i++)
      for (j=0; j<numComponenti; j++) {
        (new Test(i,j,p)).start();
      }
  
    // attende 3 secondi prima di aprire la porta (tutti i thread devono attendere)
    sleep(3000);
    p.apri();
    System.out.println("La porta e' aperta!!");
  }
  
}
Mostra soluzione

[sourcecode lang=”java”]
/*
* COMMENTO GENERALE:
*
* Illustrare la soluzione proposta spiegando accuratamente:
* – Come si è arrivati a scegliere le strutture dati utilizzate
* per la sincronizzazione
*
* Utilizziamo:
* – un intero ‘numComponenti’ per memorizzare il numero componenti di
* ogni squadra (passato al costruttore)
* – un intero ‘lastEntered’ per sapere l’indice dell’ultimo giocatore
* entrato, in modo da preservare l’ordine
* – un intero ‘currentColor’ che indica il colore della squadra che sta
* entrando. Lo inializzamo a -1 per indicare che nessuna squadra sta
* entrando
* – un boolean ‘aperta’ che indica se la porta è aperta (inizializzato a
* false)
*
* – Come funziona, intuitivamente, la sincronizzazione
*
* Il metodo ‘attendi’ attende finché la porta non viene aperta e
* ‘apri’ apre la porta notificando tutti i thread. Il metodo ‘entra’
* è diviso in due casi:
*
* 1. Il capitano attende che la squadra precedente sia entrata
* tutta e, se riesce ad entrare, setta il colore corrente alla
* propria squadra
* 2. Gli altri giocatori attendono che il colore corrente sia quello
* della propria squadra e che sia il proprio turno
*
* – Come sono state utilizzate le wait e le notify / notifyAll
*
* Nel metodo ‘attendi’ viene fatta una wait finché la porta non viene
* aperta (!aperta). Il metodo apri pone aperta=true e fa una notifyAll
* per sbloccare tutti i thread.
* Nel metodo ‘entra’ il capitano attende finché non è entrato
* l’ultimo giocatore (lastEntered != numComponenti-1) mentre gli altri
* giocatori attendono finché non è il proprio colore e turno
* (currentColor != col || lastEntered+1 != num). Quando entrano fanno
* una notifyAll per svegliare i giocatori successivi (devono notificarli
* tutti perché non c’è modo di sapere chi è il prossimo in coda).
* Come al solito le condizioni di bloccaggio sono in un while per
* fare ri-controllare la condizione dopo una notifyAll.
*
* Commentare, inoltre, accuratamente il codice delle funzioni.
*
* Una consegna è insufficiente se:
* – non funziona (anche se commentata accuratamente)
* – i commenti sono assenti / scarsi / non accurati
* – realizza la sincronizzazione in modo non chiaro o inutilmente complesso
*/

public class Porta {
private int numComponenti; // numero componenti della squadra
private int lastEntered; // quale componente è entrato per ultimo
private int currentColor=-1; // colore attualmente nella porta
private boolean aperta=false;// porta aperta

Porta(int numComponenti) {
this.numComponenti = numComponenti; // numero componenti squadra
// ultimo entrato lo inizializzamo come se fosse entrato
// l’ultimo della squadra precedente in modo da dare il
// via libera al capitano della squadra
lastEntered = numComponenti-1;
}

public synchronized void apri() {
// apre la porta e notifica tutti
aperta = true;
notifyAll();
}

public synchronized void attendi() throws InterruptedException {
// finché la porta è chiusa attende
while (!aperta)
wait();
}

public synchronized void entra(int col, int num) throws InterruptedException {
if ( num == 0) { // capitano
// il capitano attende se la squadra precedente non è entrata tutta
while (lastEntered != numComponenti-1)
wait();
// prima di entrare setta il colore corrente a quello della
// propria squadra
currentColor = col;
} else // gli altri giocatori
// gli altri attendono se non è il proprio colore o turno
while (currentColor != col || lastEntered+1 != num)
wait();

// memorizza che sta entrando e notifica tutti
lastEntered = num;
notifyAll();
}

}
[/sourcecode]