traccia completa con variante

Author: totoLab

sistemiOperativi/esercitazioni/src/tracce/supermercato/Cassa.java

@@ -1,13 +1,47 @@
 package tracce.supermercato;
 
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+
 public abstract class Cassa {
 
- abstract void svuotaCarrello(int N);
+ final int numeroCasse;
+
+ public Cassa(int numeroCasse) {
+ this.numeroCasse = numeroCasse;
+ }
+
+ abstract void svuotaCarrello(int N) throws InterruptedException;
+
+ abstract void scansiona() throws InterruptedException;
+
+ abstract void paga(int N) throws InterruptedException;
+
+ abstract void prossimoCliente() throws InterruptedException;
 
- abstract void scansiona();
+ void attesa(int t) {
+ try {
+ TimeUnit.SECONDS.sleep(t);
+ } catch (InterruptedException e) { e.printStackTrace(); }
+ }
 
- abstract void paga(int N);
+ void attesa(int t1, int t2) {
+ Random random = new Random();
+ attesa(random.nextInt(t1, t2));
+ }
 
- abstract void prossimoCliente();
+ void log(String msg) {
+ long id = Thread.currentThread().getId();
+ String finalMsg = String.format("[%d] %s", id, msg);
+ System.out.println(finalMsg);
+ }
 
+ void test(int numeroClienti) {
+ for (int i = 0; i < numeroCasse; i++) {
+ new Cassiere(this, i).start();
+ }
+ for (int i = 0; i < numeroClienti; i++) {
+ new Cliente(this).start();
+ }
+ }
 }

sistemiOperativi/esercitazioni/src/tracce/supermercato/CassaSem.java

@@ -1,23 +1,58 @@
 package tracce.supermercato;
 
+import java.util.concurrent.Semaphore;
+
 public class CassaSem extends Cassa {
- @Override
- void svuotaCarrello(int N) {
 
+ Semaphore mutex = new Semaphore(1);
+ int prodotti = 0;
+ Semaphore prossimoCliente = new Semaphore(1);
+ Semaphore puoPagare = new Semaphore(0);
+ Semaphore pagato = new Semaphore(0);
+ Semaphore puoScansionare = new Semaphore(0);
+
+ public CassaSem() {
+ super(1);
  }
 
  @Override
- void scansiona() {
-
+ void svuotaCarrello(int N) throws InterruptedException {
+ log("Buongiorno");
+ prossimoCliente.acquire();
+ log("Svuoto il carrello");
+ mutex.acquire();
+ prodotti += N;
+ mutex.release();
+ log("Finito di svuotare il carrello");
+ puoScansionare.release();
  }
 
  @Override
- void paga(int N) {
+ void scansiona() throws InterruptedException {
+ puoScansionare.acquire();
+ log("Comincio a scansionare...");
+ attesa(5 * prodotti);
+ log("Fine scansione, può pagare");
+ puoPagare.release();
+ }
 
+ @Override
+ void paga(int N) throws InterruptedException {
+ log("Attendo di pagare");
+ puoPagare.acquire();
+ log("Importo: €" + 5 * N);
+ pagato.release();
  }
 
  @Override
- void prossimoCliente() {
+ void prossimoCliente() throws InterruptedException {
+ pagato.acquire();
+ log("Prossimo cliente");
+ prossimoCliente.release();
+ }
 
+ public static void main(String[] args) {
+ Cassa cassa = new CassaSem();
+ cassa.test(3);
  }
 }

sistemiOperativi/esercitazioni/src/tracce/supermercato/CassaSem2.java

@@ -0,0 +1,98 @@
+package tracce.supermercato;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.Semaphore;
+
+public class CassaSem2 extends Cassa {
+
+ Semaphore mutex = new Semaphore(1);
+ int[] prodotti;
+ Semaphore[] prossimoCliente;
+ Semaphore[] puoPagare;
+ Semaphore[] pagato;
+ Semaphore[] puoScansionare;
+ int[] personeInFila;
+
+ Map<Thread, Integer> clientiCassa = new HashMap<>();
+
+ CassaSem2(int numeroCasse) {
+ super(numeroCasse);
+ this.prodotti = new int[numeroCasse];
+ this.prossimoCliente = new Semaphore[numeroCasse];
+ this.puoPagare = new Semaphore[numeroCasse];
+ this.pagato = new Semaphore[numeroCasse];
+ this.puoScansionare = new Semaphore[numeroCasse];
+ this.personeInFila = new int[numeroCasse];
+ for (int i = 0; i < numeroCasse; i++) {
+ prodotti[i] = 0;
+ prossimoCliente[i] = new Semaphore(1);
+ puoPagare[i] = new Semaphore(0);
+ pagato[i] = new Semaphore(0);
+ puoScansionare[i] = new Semaphore(0);
+ personeInFila[i] = 0;
+ }
+ }
+
+ void scegliCassa() {
+ int ret = 0;
+ int min = personeInFila[ret];
+ for (int i = 1; i < numeroCasse; i++) {
+ if (personeInFila[i] < min) {
+ min = personeInFila[i];
+ ret = i;
+ }
+ }
+ clientiCassa.put(Thread.currentThread(), ret);
+ }
+
+ int getCassa() {
+ return clientiCassa.get(Thread.currentThread());
+ }
+
+ int getCassiere() {
+ return ((Cassiere) Thread.currentThread()).id;
+ }
+
+ @Override
+ void svuotaCarrello(int N) throws InterruptedException {
+ log("Buongiorno");
+ mutex.acquire();
+ scegliCassa();
+ mutex.release();
+ prossimoCliente[getCassa()].acquire();
+ log("Svuoto il carrello");
+ prodotti[getCassa()] += N;
+ log("Finito di svuotare il carrello");
+ puoScansionare[getCassa()].release();
+ }
+
+ @Override
+ void scansiona() throws InterruptedException {
+ puoScansionare[getCassiere()].acquire();
+ log("Comincio a scansionare...");
+ attesa(2 * prodotti[getCassiere()]);
+ log("Fine scansione, può pagare");
+ puoPagare[getCassiere()].release();
+ }
+
+ @Override
+ void paga(int N) throws InterruptedException {
+ log("Attendo di pagare");
+ puoPagare[getCassa()].acquire();
+ log("Importo: €" + 5 * N);
+ pagato[getCassa()].release();
+ }
+
+ @Override
+ void prossimoCliente() throws InterruptedException {
+ pagato[getCassiere()].acquire();
+ log("Prossimo cliente");
+ prossimoCliente[getCassiere()].release();
+ }
+
+ public static void main(String[] args) {
+ Cassa cassa = new CassaSem2(2);
+ cassa.test(5);
+ }
+}

sistemiOperativi/esercitazioni/src/tracce/supermercato/Cassiere.java

@@ -1,4 +1,22 @@
 package tracce.supermercato;
 
 public class Cassiere extends Thread {
+
+ Cassa cassa;
+ int id;
+
+ Cassiere(Cassa cassa, int id) {
+ this.cassa = cassa;
+ this.id = id;
+ }
+
+ @Override
+ public void run() {
+ while (true) {
+ try {
+ cassa.scansiona();
+ cassa.prossimoCliente();
+ } catch (InterruptedException e) { e.printStackTrace(); }
+ }
+ }
 }

sistemiOperativi/esercitazioni/src/tracce/supermercato/Cliente.java

@@ -1,4 +1,25 @@
 package tracce.supermercato;
 
+import java.util.Random;
+
 public class Cliente extends Thread {
+
+ Cassa cassa;
+
+ Cliente(Cassa cassa) {
+ this.cassa = cassa;
+ }
+
+ @Override
+ public void run() {
+ try {
+ Random random = new Random();
+ int N = random.nextInt(1, 21);
+ cassa.log("Faccio la spesa... " + N);
+ cassa.attesa(2 * N);
+ cassa.svuotaCarrello(N);
+ cassa.paga(N);
+ cassa.log("Arrivederci");
+ } catch (InterruptedException e) { e.printStackTrace(); }
+ }
 }