codice:
public class BufferLimitato{
public static final int SLEEP_TIME = 5;
private static final int BUFFER_SIZE = 2;
private Semaforo mutex;
private Semaforo empty;
private Semaforo full;
private int count;
private int in, out;
private Object[] buffer;
public BufferLimitato(){
count=0;
in=0;
out=0;
buffer = new Object[BUFFER_SIZE];
mutex = new Semaforo(1);
empty = new Semaforo(BUFFER_SIZE);
full = new Semaforo(0);
}
public BufferLimitato(int size){
count=0;
in=0;
out=0;
buffer = new Object[size];
mutex = new Semaforo(1);
empty = new Semaforo(BUFFER_SIZE);
full = new Semaforo(0);
}
public static void napping(){
int sleepTime=(int)(SLEEP_TIME * Math.random());
try{
Thread.sleep(sleepTime*1000);
}catch(InterruptedException e){
}
}
public void inserisce(Object item){
empty.P();
mutex.P();
count++;
buffer[in]=item;
in=(in+1)%BUFFER_SIZE;
if(count==BUFFER_SIZE)
System.out.println("Produttore ha inserito " + item + " - buffer PIENO");
else
System.out.println("Produttore ha inserito " + item + " - dimensione buffer = " + count);
mutex.V();
full.V();
}
public Object rimuove(){
Object item;
full.P();
mutex.P();
count--;
item=buffer[out];
out=(out+1)%BUFFER_SIZE;
if(count==0)
System.out.println("Consumatore ha consumato " + item + " - Buffer VUOTO");
else
System.out.println("Consumatore ha consumato " + item + " - dimensione buffer = " + count);
mutex.V();
empty.V();
return item;
}
}
codice:
public final class Semaforo{
private int value;
public Semaforo(){
value = 0;
}
public Semaforo(int v){
value = v;
}
public synchronized void P(){
while (value<=0){
try{
wait();
}catch (InterruptedException e){
}
}
value--;
}
public synchronized void V(){
value++;
notify();
}
}
codice:
public class Produttore extends Thread{
private BufferLimitato buffer;
public Produttore (BufferLimitato b){
buffer=b;
}
public void run(){
Date message;
while(true){
BufferLimitato.napping();
message = new Date();
buffer.inserisce(message);
}
}
}
codice:
public class ConsumatoreA extends Thread{
private BufferLimitato buffer;
public ConsumatoreA(BufferLimitato b){
buffer = b;
}
public void run(){
Date message;
while (true) {
BufferLimitato.napping();
message = (Date)buffer.rimuove();
System.out.println("ConsA: "message);
}
}
}
e consumatoreB è analogo a consumatoreA
queste sono le classi che ho fatto fino ad ora... penso (in questo momento non sono sicuro di nulla dato che è la prima volte che mi trovo ad affrontare un problema di programmazione sui thread) che dovrò modificare la classe condumatoreB in modo da far gestire la priorità...
sinceramente non ho capito molto l'ultima parte con il codice... non dovrebbe essere un'implementeazione simile a quella che ho fatto io??
per quanto riguarda la variabile di controllo...
il vettore in condivisione è unico e gli oggetti che sono dentro sono tutti uguali... consumatoreA potrà prelevare oggetti dal vettore quando gli pare (naturalmente controllando se c'è o non c'è lock sulla risorsa) e consumatoreB potrà prelevare dati solo se non ci sono thread consumatoreA in stato di attesa...
cmq i thread consumatoreB dovranno riuscire a prendere il lock sulla risorsa prima o poi...
qual era la tua idea??
Rispondi quotando
