Ragazzi ho problemi con un semplice esercizio Produttore-Consumatore, "applicato" ad un pronto soccorso.
E' il primo esercizio su questo argomento e quindi è molto molto semplice; come struttura dati ho usato una LinkedList gestita come una coda, quindi l'ultimo arrivato viene accodato ed il primo viene prelevato dalla testa(non usato i vari codici e quindi code di priorità, ma tutti i pazienti hanno lo stesso codice).
La dimensione della coda la posso scegliere dal main.
C'è la classe Paziente:
codice:
public class Paziente{
private String nome;
private String cognome;
public Paziente(String nome, String cognome)
{
this.nome=nome;
this.cognome=cognome;
}
public String toString ()
{
return ("Cognome: " + cognome + "\n" + "Nome: " + nome + "\n");
}
}
Poi c'è la classe Buffer:
codice:
import java.util.LinkedList;
public class Buffer<E> {
private LinkedList<E> coda;
private int capacità;
public Buffer(int capacità)
{
this.capacità=capacità;
coda=new LinkedList<E>();
}
public synchronized boolean isEmpty()
{
return (coda.size()==0);
}
public synchronized boolean isFull()
{
return (coda.size()>=capacità);
}
public synchronized void aggiungi(E elem)
{
while(isFull())
{
try
{
wait();
}
catch(InterruptedException e){}
}
coda.addLast(elem);
notifyAll();
}
public synchronized E preleva ()
{
while(isEmpty())
{
try
{
wait();
}
catch(InterruptedException e){}
}
notifyAll();
return (coda.removeFirst());
}
}
Poi c'è la classe Consumatore:
codice:
public class Consumatore implements Runnable {
private Buffer<Paziente> buffer;
private int ritardo;
public Consumatore (Buffer<Paziente> buffer, int ritardo)
{
this.ritardo=ritardo;
this.buffer=buffer;
}
public void run() {
int i;
while(true)
{
Paziente p = buffer.preleva();
System.out.println ("Prelevato: " + p + "\n" );
try
{
Thread.sleep(ritardo);
}
catch(InterruptedException e){}
}
}
}
La classe Produttore:
codice:
public class Produttore implements Runnable{
private Buffer<Paziente> buffer;
private int ritardo;
public Produttore (Buffer<Paziente> buffer, int ritardo)
{
this.buffer=buffer;
this.ritardo=ritardo;
}
public void run() {
int i;
for(i=0; true; i++)
{
Paziente p = new Paziente("Nome " + i, "Cognome " + i);
buffer.aggiungi(p);
System.out.println("Inserito: " + p);
try
{
Thread.sleep(ritardo);
}
catch(InterruptedException e){}
Thread.yield();
}
}
}
E per finire ho scritto un semplice Test:
codice:
public class TestProntoSoccorsoCoda {
public static void main(String[] args) {
Buffer<Paziente> buffer;
Produttore prod;
Consumatore cons;
buffer=new Buffer<Paziente>(1);
prod=new Produttore(buffer, 1000);
cons=new Consumatore(buffer, 1000);
Thread consumator=new Thread(cons);
Thread producer=new Thread(prod);
producer.start();
consumator.start();
}
}
Dal main posso scegliere la velocità di produzione e la velocità di consumo, ed anche la dimensione del buffer.
Il problema che si verifica è che sulla console ci sono dei Pazienti curati prima che vengano inseriti nel buffer, oppure vengono effettuati più inserimenti successivi anche se la dimensione non lo permetterebbe.
Per esempio se scelgo dimensione 1, allora si dovrà avere un'alternanza continua tra curati e inseriti, ossia non ci possono essere due inseriti o due curati consecutivi proprio perché la struttura dati ha dimensione fisica massima pari ad uno; ma effettuando il test dalla console risulta che alcune volte ci sono due curati consecutivi, però il bello è che cura il malato che verrà inserito subito dopo.
Ad esempio arriva il paziente1 e poi cura il paziente1, poi cura il paziente2 e poi arriva il paziente2; ma come ma fa a curarlo se ancora non è arrivato?
Io sono arrivato alla conclusione che si tratti di un problema di console o di stampa, cioè il paziente viene inserito nella struttura dati ma sulla console viene stampato prima il messaggio di cura che di inserimento (per qualche ritardo della console o non sò).
Un problema di struttura non c'è perchè anche se effettua due inserimento successivi, ad esempio del paziente n e del paziente n+1, poichè la dim massima è 1, un paziente dovrebbe andar perso, ma così non è perchè successivamente vengono curati entrambi.
Scusate se mi sono dilungato, ma volevo essere chiaro e far capire il problema.
Confido in un vostro aiuto 
Grazie