[monitor] Incrocio con pedoni – Secgroup Ca' Foscari

Ci sono automobili e pedoni che si approcciano a un incrocio. I pedoni hanno la precedenza sulle auto.

Le auto si comportano secondo il seguente schema:

finche' sulla strada:
 
    Se accede all'incrocio:
        incr.arrivaAuto(); // indica che sta per attraversare
    Se esce dall'incrocio:
        incr.attraversatoAuto(); // indica che ha attraversato
                 
    incr.muovi(c,x,y,dx,dy); // la macchina si muove se ha strada
    x+=dx; y+=dy;
         
incr.libera(x,y); // esce dalla strada

I pedoni si comportano secondo il seguente schema:

finche' sulla strada:
 
    Se accede all'incrocio:
        incr.arrivaPedone(); // indica che sta per attraversare
    Se esce dall'incrocio:
        incr.attraversatoPedone(); // indica che ha attraversato
                 
    incr.muovi(c,x,y,dx,dy); // il pedone si muove se ha strada
    x+=dx; y+=dy;
         
incr.libera(x,y); // esce dalla strada

Progettare un monitor Incrocio che implementi i seguenti metodi:

void muovi(char c, int x, int y, int dx, int dy)
  se la posizione x+dx,y+dy e' occupata attende. Altrimenti scrive c in tale posizione e libera
  la posizione attuale x,y scrivendo uno spazio
 
void libera(int x, int y)
  libera la posizione x,y scrivendo uno spazio
 
char strada(int x, int y)
  ritorna il carattere (auto o spazio) in posizione x,y (serve per stampare le auto)
 
void arrivaAuto() 
  Se ci sono pedoni in attesa o in attraversamento attende
 
void attraversatoAuto() 
  Indica che ha finito di attraversare l'incrocio
 
void arrivaPedone() 
  Se ci sono auto in attraversamento attende, ma ha la precedenza
 
void attraversatoPedone() 
  Indica che ha finito di attraversare l'incrocio

In particolare notare che le auto attendono se ci sono pedoni in attesa o attraversamento (dando quindi la precedenza ai pedoni). I pedoni, invece, attendono solo se ci sono auto in attraversamento.

Scaricare qui il codice sorgente.

Visualizza la soluzione

Soluzione

Segue una possibile soluzione commentata della verifica:

/*
 * Descrizione generale: utilizziamo 2 contatori
 * 
 * - pedoni: numero di pedoni in attesa o attraversamento
 * - auto: numero di auto in attraversamento
 * 
 * Il contatore pedoni viene incrementato all'inizio di arrivaPedone() in modo da
 * conteggiare sia i pedoni in attesa che quelli in attraversamento. Il contatore
 * auto invece viene incrementato dopo che l'auto ha atteso eventuali pedoni,
 * alla fine del metodo arrivaAuto(), in modo da conteggiare solo le auto in
 * attraversamento (e non quelle in attesa). In questo modo è sufficiente che le
 * auto attendano finché pedoni>0 e che i pedoni attendano finché auto>0.
 * L'ultimo thread auto (o pedone) che esce dall'incrocio esegue una notifyAll
 * per risvegliare eventuali pedoni (o auto) in attesa di poter attraversare
 * l'incrocio.
 * 
 * Dentro il metodo muovi bisogna attendere finché strada[x+dx][y+dy] != ' ', per
 * evitare che auto e pedoni si sovrappongano (l'accesso alla strada deve
 * avvenire in mutua esclusione). Quando viene liberata una cella (metodo libera)
 * si deve fare una notifyAll per sbloccare eventuali pedoni o auto in attesa
 * dentro il metodo muovi.
 */
 
public class Incrocio {
    int DIM;
    char[][] strada;
    int pedoni = 0; // numero di pedoni in attesa o attraversamento
    int auto = 0;   // numero di auto in attraversamento
 
    public Incrocio(int DIM) {
        int i,j;
        this.DIM = DIM;
        this.strada = new char[DIM][DIM];
        for (i=0;i<DIM;i++)
            for (j=0;j<DIM;j++)
                strada[i][j] = ' ';
    }
 
    public synchronized void muovi(char c, int x, int y, int dx, int dy) throws InterruptedException{
        // attende finché la cella in cui deve muoversi è occupata
        while (strada[x+dx][y+dy] != ' ')
            wait();
        strada[x+dx][y+dy]= c;
        libera(x,y);
    }
 
    public synchronized void libera(int x, int y) {
        strada[x][y] = ' ';
        // notifica eventuali auto o pedoni in attesa di muoversi (metodo muovi)
        notifyAll(); 
 
    }
    public char strada(int x, int y) {
        return strada[x][y];
    }
 
 
    public synchronized void arrivaAuto() throws InterruptedException {
        // finché ci sono pedoni in attesa o attraversamento attende
        // (precedenza ai pedoni)
        while(pedoni>0)
            wait();
        auto += 1; // un'auto in più in attraversamento
 
    }
 
    public synchronized void attraversatoAuto() {
        auto -= 1; // un'auto in meno in attraversamento
        if (auto == 0)
            // se è l'ultima auto nell'incrocio notifica eventuali pedoni in attesa
            notifyAll(); 
    }
    public synchronized void arrivaPedone() throws InterruptedException {
        pedoni += 1; // un pedone in più in attesa o attraversamento
        // finché ci sono auto in attraversamento attende (non attende auto in
        // attesa, perché i pedoni hanno la precedenza)
        while(auto > 0)
            wait(); 
    }
 
    public synchronized void attraversatoPedone() {
        pedoni -= 1; // un pedone in meno in attraversamento o attesa
        if (pedoni == 0)
            // se è l'ultimo pedone nell'incrocio notifica eventuali auto in attesa
            notifyAll(); 
    }
}