Problema con i monitor:
 A Scelta dei monitor
   1. si individuano i dati condivisi o le risorse condivise
   2. partizionare le risorse condivise in insiemi minimali dipendenti
 B Individuare le condizioni "di accesso"
   I casi sono due:
    1 [Problema semplice]
      Tutte le condizioni coinvolgono esclusivamente variabili condivise

      Ci serve una variabile di condizione cB per ogni condizione B.
      Tutte le procedure entry hanno la seguente forma:

         output nome(input) {
            /* fase 1: verifichiamo se la condizione non e' soddisfatta
                       e in tal caso ci sospendiamo */
            if(!B) waitc(cB);
            ....  /* alterando i dati condivisi */
            /* fase di uscita: risvegliamo i processi da risvegliare */
            if(B1) signalc(cB1);
            ...
            if(Bn) signalc(cBn);
         }

       Sul deadlock non si puo' dire nulla.
       Per ogni condizione cBi la politica e' FIFO.
       La starvation dipende dall'ordine con il quale vengono testate le condizioni Bi
       e dalle condizioni Bi stesse.
       Esempio: lettori vs scrittori (starvation per priorita' ai lettori o agli
        scrittori). La starvation si evita cambiando le Bi per tenere conto dell'ultima
        classe di processi che ha avuto accesso al db.

    2 [Problema complesso]
      Almeno una condizione coinvolge variabili del processo

      Per ogni condizione Bi (funzione dei dati locali) dichiaro una variabile
      di condizione cBi e un interno ni che indica il numero di processi in attesa
      di una signal su cBi.      

      - Soluzione 1: (a la Java)

         output nome(input) {
            /* fase 1: verifichiamo se la condizione non e' soddisfatta
                       e in tal caso ci sospendiamo */
            while(!B) {ni++; waitc(cB); ni--;}
            ....  /* alterando i dati condivisi */
            /* fase di uscita: risvegliamo i processi da risvegliare */
            for(j=0;j<n1;j++) signalc(cB1);  // in Java notifyAll()
            ...
            for(j=0;j<nn;j++) signalc(cBn);
         }

        Problemi:
          a) spreco di risorse
          b) deadlock: non si puo' dire nulla [ o anche livelock se dentro al ciclo
             while(!B) per qualche ragione metto una signalc() ]
          c) nessuna proprieta' FIFO sulle singole condition
             SOLUZIONE TROPPO COSTOSA:
              se il primo si sveglia e deve rimettersi in coda, allora tutti quelli dopo
              di lui in coda debbono essere svegliati al solo fine di mettersi in coda
              cosi' che alla fine la coda risulti inalterata
          d) starvation: estremamente difficile da evitare se non c'e' FIFO sulle
             singole condition

      - Soluzione 2: chi si addormenta deve rendere pubbliche le variabili del processo
         che servono a determinare se la condizione su cui si e' addormentato a un certo
         punto diventi vera

         A questo punto la soluzione diventa quasi identica a quella per i problemi
         semplici

         Problemi:
          a) tutti quelli della soluzione semplice
          b) problemi di privacy

         output nome(input) {
            /* fase 1: verifichiamo se la condizione non e' soddisfatta
                       e in tal caso ci sospendiamo */
            if(!Bi) { push(i,dati_locali); waitc(cB); pop(i);}
            ....  /* alterando i dati condivisi */
            /* fase di uscita: risvegliamo i processi da risvegliare */
            dati_locali = peep(i); if(B1) signalc(cB1);
            ...
            dati_locali = peep(i); if(Bn) signalc(cBn);
         }

         POSSIBILE ALTERNATIVA SENZA CODA:

         int bB = 0;  // se c'e' qualcuno sospeso in coda

         output nome(input) {
            /* fase 1: verifichiamo se la condizione non e' soddisfatta
                       e in tal caso ci sospendiamo */
            if(!B) {
              if (bB > 0) {
               wait(precB);
              }
              bB++;
              pubblica_dati_locali();
              waitc(cB);
              bB--;}
            ....  /* alterando i dati condivisi */
            /* fase di uscita: risvegliamo i processi da risvegliare */
            if(B1) {signalc(cB1); signal(precB1);}
            ...
            if(Bn) {signalc(cBn); signal(precB1);}
         }