traccia da controllare

Author: totoLab

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

@@ -0,0 +1,36 @@
+package tracce.ufficiopostale;
+
+import java.util.Random;
+
+public class Cliente extends Thread {
+
+ UfficioPostale ufficio;
+
+ Cliente(UfficioPostale ufficio) {
+ this.ufficio = ufficio;
+ }
+
+ @Override
+ public void run() {
+ try {
+ Random random = new Random();
+ String operazione = null;
+ switch (random.nextInt(3)) {
+ case 0:
+ operazione = "A";
+ break;
+ case 1:
+ operazione = "B";
+ break;
+ case 2:
+ operazione = "C";
+ break;
+ }
+ boolean disponibile = ufficio.ritiraTicket(operazione);
+ if (disponibile) {
+ ufficio.attendiSportello(operazione);
+ }
+ ufficio.log("Arrivederci", -1);
+ } catch (InterruptedException e) { e.printStackTrace(); }
+ }
+}

sistemiOperativi/esercitazioni/src/tracce/ufficiopostale/Impiegato.java

@@ -0,0 +1,22 @@
+package tracce.ufficiopostale;
+
+public class Impiegato extends Thread {
+
+ UfficioPostale ufficio;
+ int tipo;
+
+ Impiegato(UfficioPostale ufficio, int tipo) {
+ this.ufficio = ufficio;
+ this.tipo = tipo;
+ }
+
+ @Override
+ public void run() {
+ while (true) {
+ try {
+ ufficio.prossimoCliente();
+ ufficio.eseguiOperazione();
+ } catch (InterruptedException e) { e.printStackTrace(); }
+ }
+ }
+}

sistemiOperativi/esercitazioni/src/tracce/ufficiopostale/UfficioPostale.java

@@ -0,0 +1,60 @@
+package tracce.ufficiopostale;
+
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+
+public abstract class UfficioPostale {
+
+ int numeroImpiegatiPerTipo;
+
+ UfficioPostale(int numeroImpiegatiPerTipo) {
+ this.numeroImpiegatiPerTipo = numeroImpiegatiPerTipo;
+ }
+
+ abstract boolean ritiraTicket(String operazione) throws InterruptedException;
+
+ abstract void attendiSportello(String operazione) throws InterruptedException;
+
+ abstract void prossimoCliente() throws InterruptedException;
+
+ abstract void eseguiOperazione() throws InterruptedException;
+
+ void attesa(int t) {
+ try {
+ TimeUnit.SECONDS.sleep(t);
+ } catch (InterruptedException e) { e.printStackTrace(); }
+ }
+
+ void attesa(int t1, int t2) {
+ Random random = new Random();
+ attesa(random.nextInt(t1, t2));
+ }
+
+ void log(String msg, int tipo) {
+ String codice = null;
+ switch (tipo) {
+ case 0:
+ codice = "A"; break;
+ case 1:
+ codice = "B"; break;
+ case 2:
+ codice = "C"; break;
+ default:
+ codice = "Cliente"; break;
+ }
+ long id = Thread.currentThread().getId();
+ String finalMsg = String.format("[%d] %s: %s", id, codice, msg);
+ System.out.println(finalMsg);
+ }
+
+ void test(int numeroClienti) {
+ for (int j = 0; j < 3; j++) {
+ for (int i = 0; i < numeroImpiegatiPerTipo; i++) {
+ new Impiegato(this, j).start();
+ }
+ }
+ for (int i = 0; i < numeroClienti; i++) {
+ new Cliente(this).start();
+ }
+ }
+}

sistemiOperativi/esercitazioni/src/tracce/ufficiopostale/UfficioPostaleLC.java

@@ -0,0 +1,123 @@
+package tracce.ufficiopostale;
+
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class UfficioPostaleLC extends UfficioPostale {
+
+ int[] durataOperazione = new int[] { 3, 5, 7};
+
+ Lock l = new ReentrantLock();
+ Condition possoRitirare = l.newCondition();
+
+ LinkedList<Thread> coda = new LinkedList<>();
+ int[] ticketEmessi = new int[] { 0, 0, 0 };
+ final int TICKET_MAX = 50;
+
+ Map<Integer, LinkedList<Thread>> sportelli = Map.of(
+ 0, new LinkedList<>(),
+ 1, new LinkedList<>(),
+ 2, new LinkedList<>()
+ );
+ Condition turnoSportello = l.newCondition();
+ boolean[] clienteAlloSportello = new boolean[] { false, false, false };
+ Condition[] clienteDisponibile = new Condition[] { l.newCondition(), l.newCondition(), l.newCondition() };
+
+ boolean[] operazioneTerminata = new boolean[] { false, false, false };
+ Condition[] termineOperazione = new Condition[] { l.newCondition(), l.newCondition(), l.newCondition() };
+
+ UfficioPostaleLC(int numeroImpiegatiPerTipo) {
+ super(numeroImpiegatiPerTipo);
+ }
+
+ int converti(String operazione) {
+ Map<String, Integer> op = Map.of(
+ "A", 0,
+ "B", 1,
+ "C", 2
+ );
+ return op.get(operazione);
+ }
+
+ @Override
+ boolean ritiraTicket(String operazione) throws InterruptedException {
+ l.lock();
+ try {
+ coda.add(Thread.currentThread());
+ while (!Thread.currentThread().equals(coda.getFirst())) {
+ possoRitirare.await();
+ }
+ coda.removeFirst();
+ int codice = converti(operazione);
+ if (ticketEmessi[codice] == TICKET_MAX) return false;
+ ticketEmessi[codice]++;
+ possoRitirare.signalAll();
+ return true;
+ } finally {
+ l.unlock();
+ }
+ }
+
+ boolean mioTurno(int codice) {
+ return Thread.currentThread().equals(sportelli.get(codice).getFirst());
+ }
+
+ @Override
+ void attendiSportello(String operazione) throws InterruptedException {
+ l.lock();
+ try {
+ int codice = converti(operazione);
+ while (!mioTurno(codice)) {
+ turnoSportello.await();
+ }
+ clienteAlloSportello[codice] = true;
+ while (!operazioneTerminata[codice]) {
+ termineOperazione[codice].await();
+ }
+
+ } finally {
+ l.unlock();
+ }
+ }
+
+ @Override
+ void prossimoCliente() throws InterruptedException {
+ l.lock();
+ try {
+ turnoSportello.signalAll();
+ } finally {
+ l.unlock();
+ }
+ }
+
+ @Override
+ void eseguiOperazione() throws InterruptedException {
+ l.lock();
+ int codice;
+ try {
+ codice = ((Impiegato) Thread.currentThread()).tipo;
+ while (!clienteAlloSportello[codice]) {
+ clienteDisponibile[codice].await();
+ }
+ } finally {
+ l.unlock();
+ }
+
+ attesa(durataOperazione[codice]);
+
+ l.lock();
+ try {
+ termineOperazione[codice].signal();
+ } finally {
+ l.unlock();
+ }
+ }
+
+ public static void main(String[] args) {
+ UfficioPostale ufficio = new UfficioPostaleLC(1);
+ ufficio.test(200);
+ }
+}