Correction TD ProdCons [PDF]

Zitiervorschau

Rappel – Sémaphore Imene Lahyani

Variable partagée

Processus 1

Processus 2

… Section non critique s.acquire()

…Section non critique s.acquire()

…………x…….. …………x…….. Section critique 1 …………x……..

If (s>0) s=s-1 Else attendre

…………x…….. …………x…….. Section critique 2 …………x……..

s.release()

s.release ()

…Section non critique

…Section non critique

Semaphore s = new Semaphore (1, true);

s=s+1

Exercice •Un processus producteur envoie un flux d’informations à un processus consommateur. •Une zone tampon est utilisée pour faire transiter ce flux d’informations. •Le problème est de gérer l’accès à la zone tampon par le producteur et le consommateur. •La zone tampon est modélisée par un tableau partagé. •L’accès à ce tableau se fait à l’aide de deux fonctions (append et take)

Solution Consommateur

1) variable partagé ? Tampon 2) threads ? Prod , Cons 3) sections critiques ? Append (x) take()

Producteur

class ProdConsSem { ProdConsSem { // constructeur } public static void main(String argv[]) { ProdConsSem pc = new ProdConsSem(10) ; Producteur producteur = new producteur () ; Consommateur consommateur = new consommateur () ; producteur.setName("Producteur") ; producteur.start() ; consommateur.setName("Consommateur") ; consommateur.start() ; }

public static void main(String argv[]) { try{ ProdConsSem pc = new ProdConsSem(10) ; Producteur producteur = new Producteur () ; Consommateur consommateur = new Consommateur () ; producteur.setName("Producteur") ; producteur.start() ; consommateur.setName("Consommateur") ; consommateur.start() ; } catch(ArrayIndexOutOfBoundsException exp) { System.out.println("erreur"); } }}

class Producteur extends Thread { Producteur () {} Void deposer () { } public void run() { } Deposer() }

class Consommateur extends Thread { Consommateur () {} Int prelever() { } public void run() { Int x = prelever() }

import java.util.concurrent.Semaphore ;

class ProdConsSem {

static int tampon[]; static int N;

ProdConsSem (int N) { This.N=N; tampon = new int [N] ;

}

public static void main(String argv[]) { ProdConsSem pc = new ProdConsSem(10) ; Producteur producteur = new producteur () ; Consommateur consommateur = new consommateur () ; producteur.setName("Producteur") ; producteur.start() ; consommateur.setName("Consommateur") ; consommateur.start() ; }}

class Producteur extends Thread { Static Int in ; Producteur () {} Void deposer () { int m= (int)(1000*Math.random()); ProdConsSem [in] =m ; in = (in +1)% N; System.out.println(Thread.currentThread().getName() + " vient de produire "+ m) ; } public void run() { } Deposer() }

class Consommateur extends Thread { Static Int out Consommateur () {} Int prelever() { int m= ProdConsSem .tampon[tete]; out = (out + 1)% N; System.out.println(Thread.currentThread().getName() + " vient de consommer " + m) ; return m ; } public void run() { Int x = prelever() }

class Consommateur extends Thread { Static int out Consommateur () Un consommateur ne peut pas consommer d’un tampon vide {} Int Prelever() { int m= ProdConsSem .tampon[out]; out = (out + 1)% ProdConsSem .N; System.out.println(Thread.currentThread().getName() + " vient de consommer " + m) ; return m ; } public void run() { If(nbcaseplein>0) nbcaseplein=nbcaseplein-1 try { Else attendre { ProdConsSem.nbcasePlein.acquire()); ProdConsSem.S.acquire() int m = Prelever() ; ProdConsSem.S.release()); Nbcasevide=nbcasevide+1 ProdConsSem.nbcaseVide.release(); } } catch(InterruptedException e) {} } // fin run } // fin de la classe Consommateur

class Producteur extends Thread { Static int in Producteur () Un producteur ne peut pas produire dans un tampon plein {} Void deposer () {int m= (int)(1000*Math.random()); ProdConsSem .tampon[in] =m ; in = (in +1)% ProdConsSem .N; System.out.println(Thread.currentThread().getName() + " vient de produire "+ m) ;

} public void run() { try If(nbcasevide>0) nbcasevide=nbcasevide-1 { { Else attendre int m= (int)(1000*Math.random()); ProdConsSem.nbcaseVide.acquire(); ProdConsSem.S.acquire(); Deposer(m); ProdConsSem.S.release(); Nbcaseplein=nbcaseplein+1 ProdConsSem.nbcasePlein.release()(); } } catch(InterruptedException e) {} }// fin run }

import java.util.concurrent.Semaphore ;

class ProdConsSem {

static int tampon[]; static int N;

ProdConsSem (int N) { This.N=N; tampon = new int [N] ; Static nbcaseVide=new Semaphore (N, true); Static nbcasePlein=new Semaphore(0,true); Static S=new Semaphore (1,true);} public static void main(String argv[]) { ProdConsSem pc = new ProdConsSem(10) ; Producteur producteur = new producteur (pc) ; Consommateur consommateur = new consommateur (pc) ; producteur.setName("Producteur") ; producteur.start() ; consommateur.setName("Consommateur") ; consommateur.start() ; }}

Ex 2 (TD) I

P0

P1

0

Flag[0]

Flag[1]

Token

ff

ff

00

2

Flag[1]=true

f

true

0

3

Test(token0)

f

true

0

true

true

0

4

Flag[0]=true

5

Test (token0) ******SC*****

6

Token=1

7

Test(token0) ******SC*****

1

ex3 Une piscine qui contient C cabines peut contenir au maximum un nombre N de nageurs. Chaque nageur dispose d'un panier pour ranger ses habits ; il y a donc P paniers. Pour se déshabiller, les nageurs ont besoin d'une cabine et d'un panier pour placer leurs habits. Pendant qu'ils se baignent, ils conservent le panier. Après la baignade, il leur faut à nouveau une cabine pour se ré-habiller. Enfin, avant de sortir, ils libèrent le panier et la cabine. Les conditions d'utilisation sont les suivantes : 1) il y a P paniers disponibles pour ranger leurs habits ; il ne pourra donc pas y avoir plus de P baigneurs simultanément ; 2) il y a d'autre part C cabines d'habillage, avec 1 < C