Producteur(s) – Consommateur(s)

• tampon d’une case :

READ init 0, WRITE init 1.

Producteur	Consommateur
Calculer(donnée) ; Tc P(WRITE) ; Tp := donnée ; Tf V(READ) ;	P(READ) ; D := tp ; Te V(WRITE) ; Utiliser(D) ; Tu

Si Tc + Tf > Te + Tu et Tc > Te, le sémaphore WRITE n’est plus utile. Mais pour l’exportation, c’est génant.

• tampon de n cases :

READ init 0, WRITE init n, Tp[0..n-1] contient les données, in et out init 0 sont des index.

Producteur	Consommateur
Calculer(donnée) ; P(WRITE) ; Tp[in] := donnée ; In := (in +1) mod n; V(READ) ;	P(READ) ; D := tp[out] ; Out := (out +1) mod n ; V(WRITE) ; Utiliser(D) ;

• plusieurs producteurs :

Dans le cas ou il y aurait plusieurs producteur, on peut utiliser une exclusion mutuelle :
MutexP init 1 ;
m.prod(d) = { P(mutexP) ; Prod(d) ; V(mutexP) }
Cela fonctionne bien, mais bien que l’on dispose de plusieurs cases libres dans le tableau, on fait attendre des producteurs…

• plusieurs producteurs en parallèle :

Si l'on souhaite un meilleurs parallélisme des producteurs, on utilise toujours un sémaphore d'exclusion mutuelle mais on le place aux endroits importants.
MutexP init 1 ;
prod(d) = { P(WRITE); P(mutexP) ;maplace := in; in := (in+1) mod n ; V(mutexP); Tp[maplace] := d; V(READ) }
Un problème apparaït si lorsque deux producteurs écrivent en même temps, le deuxième termine avant l'autre. Le consommateur va croire qu'il peut consommer !!!

• la solution :

Prod(d)	Structures	Cons(d)
P(WRITE) P(mutexP) tant que non vide[in] faire in := (in+1) mod n maplace := in vide[in] := faux in := (in+1) mod n V(mutexP) Tp[maplace] := d P(mutexC) plein[maplace]:=vrai V(mutexC) V(READ)	WRITE init n READ init 0 mutexP, mutexC init 1 Tp[0..n-1] Vide[0..n-1] init Vrai Plein[0..n-1] init Faux in, out index sur le tableau init 0	P(READ) P(mutexC) tant que non plein[out] faire out :=(out+1) mod n maplace := out plein[out] := faux out := (out+1) mod n V(mutexC) d:=Tp[maplace] P(mutexP) vide[maplace]:=vrai V(mutexP) V(WRITE)