problemi deadlock

Author: totoLab

sistemiOperativi/esercitazioni/src/es5/barbiere/Barbiere.java

@@ -0,0 +1,29 @@
+package es5.barbiere;
+
+import java.util.concurrent.TimeUnit;
+
+public class Barbiere extends Thread {
+
+ Sala s;
+
+ Barbiere(Sala s) {
+ this.s = s;
+ }
+
+ @Override
+ public void run() {
+ try {
+ s.tagliaCapelli();
+ taglio();
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private void taglio() throws InterruptedException {
+ System.out.println("Taglio in corso...");
+ TimeUnit.SECONDS.sleep(3);
+ System.out.println("Fine taglio");
+ }
+
+}

sistemiOperativi/esercitazioni/src/es5/barbiere/Cliente.java

@@ -0,0 +1,27 @@
+package es5.barbiere;
+
+public class Cliente extends Thread {
+
+ private Sala s;
+ private int id;
+
+ Cliente(Sala s, int id) {
+ this.s = s;
+ this.id = id;
+ }
+
+ @Override
+ public void run() {
+ try {
+ System.out.printf("Cliente %d è arrivato.%n", id);
+ boolean taglioEffettuato = s.attendiTaglio();
+ if (taglioEffettuato) {
+ System.out.printf("Cliente %d ha tagliato i capelli.%n", id);
+ } else {
+ System.out.printf("Cliente %d va via.%n", id);
+ }
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ }
+ }
+}

sistemiOperativi/esercitazioni/src/es5/barbiere/Sala.java

@@ -0,0 +1,29 @@
+package es5.barbiere;
+
+import java.util.concurrent.TimeUnit;
+
+public abstract class Sala {
+
+ protected final int numSedie;
+ protected int sedieLibere;
+
+ public Sala(int sedie){
+ numSedie = sedie; sedieLibere = sedie;
+ }
+
+ public abstract void tagliaCapelli() throws InterruptedException;
+
+ public abstract boolean attendiTaglio() throws InterruptedException;
+
+ public void test(int numClienti) throws InterruptedException{
+ Barbiere b = new Barbiere(this);
+ b.setDaemon(true);
+ b.start();
+ Cliente[] clienti = new Cliente[numClienti];
+ for(int i = 0; i < numClienti; i++){
+ clienti[i] = new Cliente(this, i);
+ clienti[i].start();
+ TimeUnit.SECONDS.sleep(2);
+ }
+ }
+}

sistemiOperativi/esercitazioni/src/es5/barbiere/SalaLC.java

@@ -0,0 +1,62 @@
+package es5.barbiere;
+
+import java.util.concurrent.locks.*;
+
+public class SalaLC extends Sala {
+
+ Lock lock = new ReentrantLock();
+ Condition clienteDisponibile = lock.newCondition();
+ Condition barbiereLibero = lock.newCondition();
+ boolean poltronaLibera = false;
+
+ public SalaLC(int sedie) {
+ super(sedie);
+ }
+
+ private int clientiInAttesa() {
+ return numSedie - sedieLibere;
+ }
+
+ @Override
+ public void tagliaCapelli() throws InterruptedException {
+ lock.lock();
+ try {
+ while (clientiInAttesa() == 0) {
+ clienteDisponibile.await();
+ }
+ poltronaLibera = true;
+ barbiereLibero.signal();
+ } finally {
+ lock.unlock();
+ }
+ }
+
+ @Override
+ public boolean attendiTaglio() throws InterruptedException {
+ lock.lock();
+ try {
+ if (sedieLibere == 0) {
+ return false;
+ }
+ sedieLibere--;
+ clienteDisponibile.signal();
+ while (!poltronaLibera) {
+ barbiereLibero.await();
+ }
+ poltronaLibera = false;
+ sedieLibere++;
+ return true;
+ } finally {
+ lock.unlock();
+ }
+ }
+
+ public static void main(String[] args) {
+ SalaLC sala = new SalaLC(10);
+ try {
+ sala.test(30);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+}

sistemiOperativi/esercitazioni/src/es5/barbiere/SalaSem.java

@@ -0,0 +1,45 @@
+package es5.barbiere;
+
+import java.util.concurrent.Semaphore;
+
+public class SalaSem extends Sala {
+
+ Semaphore mutex = new Semaphore(1);
+ Semaphore clientiDisponibili = new Semaphore(0, true);
+ Semaphore poltrona = new Semaphore(0, true);
+
+ public SalaSem(int sedie) {
+ super(sedie);
+ }
+
+ @Override
+ public void tagliaCapelli() throws InterruptedException {
+ clientiDisponibili.acquire();
+ poltrona.release();
+ }
+
+ @Override
+ public boolean attendiTaglio() throws InterruptedException {
+ mutex.acquire();
+ if (sedieLibere == 0) { // se tutto occupato se ne va
+ mutex.release();
+ return false;
+ }
+ sedieLibere--;
+ mutex.release();
+ clientiDisponibili.release();
+ poltrona.acquire(); // barbiere si "addormenta" sulla poltrona
+
+ mutex.acquire();
+ sedieLibere++; // libera la sedia
+ mutex.release();
+ return true;
+ }
+
+ public static void main(String[] args) {
+ Sala s = new SalaSem(5);
+ try {
+ s.test(30);
+ } catch (InterruptedException e) {e.printStackTrace();}
+ }
+}

sistemiOperativi/esercitazioni/src/es5/bounded_buffer/Buffer.java

@@ -0,0 +1,74 @@
+package es5.bounded_buffer;
+
+import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
+
+public abstract class Buffer {
+
+ protected int[] buffer;
+ protected int in = 0, out = 0;
+
+ Buffer(int capacity) {
+ buffer = new int[capacity];
+ }
+
+ public int getCapacity() {
+ return buffer.length;
+ }
+
+ abstract void put(int i) throws InterruptedException;
+
+ abstract int get() throws InterruptedException;
+
+ public void test(int numProduttori, int numConsumatori) {
+ Produttore[] p = new Produttore[numProduttori];
+ Consumatore[] c = new Consumatore[numConsumatori];
+
+ for (int i = 0; i < numConsumatori; i++) {
+ c[i] = new Consumatore(this);
+ c[i].start();
+ }
+ for (int i = 0; i < numProduttori; i++) {
+ p[i] = new Produttore(this);
+ p[i].start();
+ }
+
+ try {
+ TimeUnit.SECONDS.sleep(10);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+
+ for (int i = 0; i < numProduttori; i++) {
+ p[i].interrupt();
+ }
+
+ for (int i = 0; i < numConsumatori; i++) {
+ c[i].interrupt();
+ }
+
+ try {
+ for (int i = 0; i < numProduttori; i++) {
+ p[i].join();
+ }
+
+ for (int i = 0; i < numConsumatori; i++) {
+ c[i].join();
+ }
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+
+ int total = 0;
+ for (int i = 0; i < numProduttori; i++) {
+ total += p[i].n_operations;
+ }
+
+ for (int i = 0; i < numConsumatori; i++) {
+ total -= c[i].n_operations;
+ }
+
+ System.out.printf("%s: operations' total is %d.%n", total >= 0 ? "Ok": "Error", total);
+ System.out.println(Arrays.toString(buffer));
+ }
+}

sistemiOperativi/esercitazioni/src/es5/bounded_buffer/BufferLC.java

@@ -0,0 +1,60 @@
+package es5.bounded_buffer;
+
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class BufferLC extends Buffer {
+
+ private int elements = 0;
+ private Lock lock = new ReentrantLock();
+ private Condition full = lock.newCondition();
+ private Condition empty = lock.newCondition();
+
+
+ BufferLC(int capacity) {
+ super(capacity);
+ }
+
+ @Override
+ void put(int i) throws InterruptedException {
+ lock.lock();
+ try {
+ while (elements == buffer.length) {
+ full.await();
+ }
+
+ buffer[in] = i;
+ in = (in + 1) % buffer.length;
+
+ elements++;
+ empty.signal();
+ } finally {
+ lock.unlock();
+ }
+ }
+
+ @Override
+ int get() throws InterruptedException {
+ lock.lock();
+ try {
+ while (elements == 0) {
+ empty.await();
+ }
+
+ int temp = buffer[out];
+ out = (out + 1) % buffer.length;
+
+ elements--;
+ full.signal();
+ return temp;
+ } finally {
+ lock.unlock();
+ }
+ }
+
+ public static void main(String[] args) {
+ Buffer bufferLC = new BufferLC(12);
+ bufferLC.test(5, 5);
+ }
+}