Università degli Studi della Calabria
This presentation is the property of its rightful owner.
Sponsored Links
1 / 22

Lucidi delle esercitazioni di Sistemi di Elaborazione in Rete PowerPoint PPT Presentation


  • 277 Views
  • Uploaded on
  • Presentation posted in: General

Università degli Studi della Calabria Corso di Laurea in Ingegneria Informatica. Lucidi delle esercitazioni di Sistemi di Elaborazione in Rete. A.A. 2003/2004. public class Database { private int readerCount; private boolean dbReading; private boolean dbWriting;

Download Presentation

Lucidi delle esercitazioni di Sistemi di Elaborazione in Rete

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Lucidi delle esercitazioni di sistemi di elaborazione in rete

Università degli Studi della CalabriaCorso di Laurea in Ingegneria Informatica

Lucidi delle esercitazioni di

Sistemi di Elaborazione in Rete

A.A. 2003/2004


Lettori scrittori con sincronizzazione java 1

public class Database {

private int readerCount;

private boolean dbReading;

private boolean dbWriting;

public Database() {

readerCount = 0;

dbReading = false;

dbWriting = false;

}

public synchronized int startRead() { /* lucidi seguenti*/ }

public synchronized int endRead() { /* lucidi seguenti */ }

public synchronized void startWrite() { /* lucidi seguenti */ }

public synchronized void endWrite() { /* lucidi seguenti */ }

}

Lettori-Scrittori con sincronizzazione Java (1)


Lettori scrittori con sincronizzazione java 2

public synchronized int startRead()

{

while (dbWriting == true) {

try {

wait();

}

catch (InterruptedException e) { }

}

readerCount++;

if (readerCount == 1)

dbReading = true;

return readerCount;

}

Lettori-Scrittori con sincronizzazione Java (2)


Lettori scrittori con sincronizzazione java 3

public synchronized int endRead()

{

readerCount- -;

if (readerCount == 0)

{

dbReading=false;

notifyAll();

}

return readerCount;

}

Lettori-Scrittori con sincronizzazione Java (3)


Lettori scrittori con sincronizzazione java 4

public synchronized void startWrite()

{

while (dbReading == true || dbWriting == true) {

try { wait(); }

catch (InterruptedException e) { }

}

dbWriting = true;

}

public synchronized void endWrite()

{

dbWriting = false;

notifyAll();

}

Lettori-Scrittori con sincronizzazione Java (4)


Lettori scrittori con sincronizzazione java 5

public class Readers extends Thread {

Database db;

int id;

public Readers(Database db,int id){

this.db=db;

this.id=id;

}

public void run(){

while (true){

db.startRead();

db.endRead();

}

}

}

Lettori-Scrittori con sincronizzazione Java (5)


Lettori scrittori con sincronizzazione java 6

public class Writers extends Thread {

Database db;

int id;

public Writers(Database db,int id){

this.db=db;

this.id=id;

}

public void run(){

while (true){

db.startWrite();

db.endWrite();

}

}

}

Lettori-Scrittori con sincronizzazione Java (6)


Lettori scrittori con sincronizzazione java 7

public class TestRW {

public static void main(String [ ] args){

Database db=new Database();

for (int i=0;i<10;i++){

(new Readers(db,i)).start();

(new Writers(db,i)).start();

}

}

Lettori-Scrittori con sincronizzazione Java (7)


Blocchi sincronizzati 1

Anche blocchi di codice, oltre che interi metodi, possono essere dichiarati synchronized.

Ciò consente di associare un lock la cui durata è tipicamente inferiore a quella di un intero metodo synchronized.

Blocchi sincronizzati (1)


Blocchi sincronizzati 2

public void syncronized F() {

// sezione non critica (p.es.: inizializzazione di variabili locali)

// sezione critica

// sezione non critica

}

public void F() {

// sezione non critica

synchronized (this) {

// sezione critica

}

// sezione non critica

}

Blocchi sincronizzati (2)


I 5 filosofi con sincronizzazione java 1

Supponiamo esista un tavolo con 5 piatti, 5 posti a tavola, 5 forchette ed al centro un’insalatiera di spaghetti. I filosofi seduti intorno al tavolo sanno fare solo due cose: mangiare e pensare. Il problema è che, siccome si tratta di spaghetti, il generico filosofo per servirsi ha bisogno di entrambe le forchette (quella alla sua DS e quella alla sua SN). Poi per mangare gliene serve solo una.

La forchetta a SN dell’i-simo filosofo è: i;

La forchetta a DS dell’i-sima filosofo è: (i+1)%5;

I 5 filosofi con sincronizzazione Java (1)

1

2

1

2

0

0

3

3

4

4


I 5 filosofi con sincronizzazione java 2 senza deadlock

Public class 5Filosofi {

private boolean fork[ ]={true,true,true,true,true};

public synchronized void getForks(int i) {

while(!fork[i] || !fork[(i+1)%5])

try{wait();

}catch(InterruptedException e){ }

fork[i]=false;

fork[(i+1)%5]=false;

notifyAll(); /*eventuale*/

}

public synchronized void putForks(int i) {

fork[i]=true;

fork[(i+1)%5]=true;

notifyAll();

}

}

I 5 filosofi con sincronizzazione Java (2)(senza deadlock)


I 5 filosofi con sincronizzazione java 3 senza deadlock e senza starvation

Public class 5Filosofi {

private boolean fork[ ]={true,true,true,true,true};

int cont[]={0,0,0,0,0};

public synchronized void getForks(int i) {

while(!fork[i] || !fork[(i+1)%5] || (cont[i]>cont[(i+1)%5)] ||

(cont[i]>cont[(i+4)%5])

try{wait();

}catch(InterruptedException e){ }

fork[i]=false;

fork[(i+1)%5]=false;

notifyAll(); /*eventuale*/

}

public synchronized void putForks(int i) {

fork[i]=true;

fork[(i+1)%5]=true;

cont[i]++;

notifyAll();

}

}

I 5 filosofi con sincronizzazione Java (3)(senza deadlock e senza starvation)


I 5 filosofi con sincronizzazione java 4 i threads filosofo

public class Filosofo extends Thread {

int id;

5Filosofi cf;

public Filosofo(int id, String nome, 5Filosofi cf) {

super(nome);

this.id=id;

this.cf=cf;

}

public void run() {

for(; ;){

cf.getForks(id);

System.out.println(“Il filosofo”+id+” mangia”);

try{

sleep((int)(Math.random()*5000));

catch(InterruptedException e){ } /*il filosofo sta mangiando*/

cf.putForks(id);

try{

sleep((int)(Math.random()*5000));}

catch(InterruptedException e){ } /*il filosofo sta pensando*/

}

}

}

I 5 filosofi con sincronizzazione Java (4)(I Threads Filosofo)


I 5 filosofi con sincronizzazione java 4 il main

public class Test5Filosofi {

public static void main(String [] args){

5Filosofi gestore=new 5Filosofi();

for (int i=0;i<5;i++)

new Filosofo(i,”Filosofo# “+i, gestore).start();

}

}

I 5 filosofi con sincronizzazione Java (4)(Il main)


Il problema dello sleeping barber

Il problema dello Sleeping Barber

  • E’ dato un salone di barbiere, avente un certo numero di posti d’attesa ed un’unica poltrona di lavoro. Nel salone lavora un solo barbiere, il quale è solito addormentarsi sulla poltrona di lavoro in assenza di clienti.

  • Arrivando nel salone, un cliente può trovare le seguenti situazioni:

  • Il barbiere dorme sulla poltrona di lavoro. Il cliente sveglia il barbiere e si accomoda sulla poltrona di lavoro, quindi il barbiere lo serve.

  • Il barbiere sta servendo un altro cliente: se ci sono posti d’attesa liberi, il cliente attende, altrimenti se ne va.

  • Scrivere in Java un programma che risolva tale problema, simulando l’attività dei diversi soggetti (il Salone, il Barbiere, i Clienti) ed evidenziandone su video lo stato.

  • L’implementazione della soluzione deve far uso delle opportune primitive di sincronizzazione e mutua esclusione.


Salone 1

Salone (1)

public class Salone implements Runnable {

int sedie,posti;

Thread barbiere=null;

boolean dorme,cliente;

boolean fineAttesa;

public Salone(int sedie){

this.sedie=sedie;

posti=sedie;

dorme=true;

cliente=false;

fineAttesa=false;

barbiere=new Thread(this);

barbiere.start();

}

public synchronized boolean richiesta ( ) { … }

public void run ( ) { … }

}


Salone richiesta 2

Salone: richiesta (2)

public synchronized boolean richiesta( ) {

if (posti==0) return false;

if ( (posti<sedie) || (!dorme)){

posti--;

while(true) {

try {wait();}catch(InterruptedException e){ }

if (fineAttesa){

fineAttesa=false;

notifyAll();

break;

}

}

cliente=true;

}

else{

dorme=false;

cliente=true;

notify();

}

while (cliente)

try{wait();}catch(InterruptedException e){}

return true;

}


Salone run 3

Salone: run (3)

public void run ( ) {

while (true){

synchronized(this) {

if (!cliente) {

if (posti==sedie) {

dorme=true;

while(dorme)

try{wait();}catch(InterruptedException e){ }

}

else{posti++;fineAttesa=true;

notify();

while (fineAttesa)

try{wait();}catch(Interrupted…){}

} /*fine synchronized*/

try{ Thread.sleep((int)(Math.random*1000));}catch(…){};

synchronized (this){

cliente=false;

notifyAll();

}

}

}

}/*fine Salone*/


Cliente 1

Cliente (1)

class Cliente extends Thread {

private Salone salone;

private int id;

public Cliente (Salone salone, int id) {

this.salone = salone;

this.id = id;

}

public void run () {

while (true) {

boolean servito=salone.richiesta();

if (servito) {

int tempoDiRicrescita = (int)((Math.random()*3000));

System.out.println ("Il cliente "+id+" attende la ricrescita dei capelli. "+"Tempo di ricrescita = "+tempoDiRicrescita);

try {

sleep (tempoDiRicrescita);

} catch (InterruptedException e) { System.out.println (e); }


Cliente 2

Cliente (2)

else{

System.out.println(“Il cliente+ id+”trova tutto pieno e va via…”);

int tempoDiRiprovo= (int)((Math.random()*1000));

try {

sleep (tempoDiRiprovo);

} catch (InterruptedException e) { System.out.println (e); }

}

} // while

}

}


Il problema dello sleeping barber1

Il problema dello Sleeping Barber

public class SleepingBarber {

public static void main (String args[]) {

int postiDiAttesa=5;

Salone s = new Salone (postiDiAttesa); /*il barbiere è già attivo*/

for (int i = 1; i <= 10; i++) {

Cliente c = new Cliente (s, i);

c.start ();

}

}

}


  • Login