Newsgroup: it.comp.java
Titolo: Java, thread e semafori

Ciao a tutti,
ho sotto gli occhi un interessante articolo apparso 
questo mese su una rivista, che parla di multithreading.
In particolare vengono fornite delle soluzioni per il 
"famoso" problema dei 5 filosofi: una sfrutta il semaforo
booleano (ma rimane il problema dello stallo), l'altra usa
un implementazione dei monitor.
Ecco come viene realizzato il semaforo:
public class SemaforoBin {
  private int stato;
  private num_attesa;
 
  public SemaforoBin() {
    stato = 1; //VERDE
    num_attesa = 0;
  }
 
  public synchronized void P() {
    if (stato == 0) {
      try {
        num_attesa++;
        wait();
        num_attesa--;
      } catch(InterruptedException ie) {}
    }  
    stato = 0;
  }
 
  public synchronized void V() {
    if (stato == 0) { //ROSSO
      if (num_attesa == 0) stato = 1;
      else notify();
    }
  }
}
Vediamo cosa succede ?
P() <--- se e` occupato, incremento num_attesa 
      (che dovrebbe essere il numero di richieste pendenti)
      e mi sospendo (wait). Quando vengo svegliato decremento
      num_attesa e occupo la risorsa (stato = 0).
V() <--- se il semaforo e' verde, non fa esattamente niente.
      se e` rosso ma nessuno lo ha richiesto (non ci sono piu`
      richieste pendenti) allora lo mette a verde, altrimenti se
      era gia` stato richiesto fa la sveglia di uno dei thread sospesi.
Spero che queste info possano essere interessanti per qualcuno
(mi pare sia passata qualche richiesta in proposito...).
Domanda: perche` uso il costrutto try, catch? Cosa puo` accadere?
-- 
Virtual address:                       
 ===========================================================================
 
se...@cli.di.unipi.it
 
m.s...@comune.livorno.it
   2:332/
60...@fidonet.org
 
 ===========================================================================

Domanda: perche` uso il costrutto try, catch? Cosa puo` accadere?
Per quanto ne so io - e sono neofitissimo - i thread si "svegliano"
sollevando un'eccezione.
Spero di non dire cagate...
Zello

 Zello
Ciao!
P.S. Una nota curiosa: vedo proprio adesso che nella documentazione del 
JDK 1.2 in mio possesso, i metodi suspend(), resume(), stop() della 
classe Thread risultano DEPRECATED. Perche'? Che facevano di male? 
Valli a capire a quelli di JavaSoft ... 8-]
-----------------------------------
\\//_  Live long and prosper .
   Lorenzo Gallucci
-----------------------------------
"There are always chances" -  Spock

 Domanda: perche` uso il costrutto try, catch? Cosa puo` accadere?
Perche', ogni volta che un thread cede il controllo (con una wait(), ad 
esempio), potrebbe "beccarsi" una InterruptedException (cosa non 
implementata ancora nel JDK 1.0 e mi pare neanche con l'1.1), a seguito 
ad esempio di una chiamata di Thread.interrupt(). Poichè è una 
interruzione che devi OBBLIGATORIAMENTE catch-are, o la dichiari come 
"throws InterruptedException" nella dichiarazione del metodo (così quando 
arriva la rispedisci indietro nello stack delle chiamate), oppure la 
acchiappi "di persona" avvolgendo la chiamata (wait()) in un blocco 
try/catch.
Tutta 'sta roba, in previsione del meccanismo di interrupt() che, ripeto, 
forse non e' ancora stato implementato, ma è già previsto nel linguaggio, 
come puoi vedere nella dichiarazione del metodo wait(), che recita 
"throws InterruptedException".
Ciao!
