Cours :Programmation Parallèle

Travaux dirigés : Série N° 1

Exercice 1 :
On considère le programme concurrent suivant :

import java.util.concurrent.*;
public class Test {
static int x = 0 ;
static Semaphore S1 = new Semaphore(1) ;
static Semaphore S2=new Semaphore(0);

public static void main(String args[])

{
P1 P11=new P1();
P11.start();
P2 P12=new P2();
P12.start();
P3 P13=new P3();
P13.start();
try{
P11.join();
P12.join();
P13.join();
}
catch(Exception e)
{}
System.out.println("x="+x);
}}
----------------------------------------
public class P1 extends Thread {
public void run()
{
try{
Test.S2.acquire() ;
Test.S1.acquire() ;
}
catch(Exception e)
{}
Test.x = Test.x * 2 ;
Test.S1.release() ;
}
}
----------------------------------------
public class P2 extends Thread {
public void run()
{
try{
Test.S1.acquire() ;
}
catch(Exception e)
{}
Test.x = Test.x * Test.x ;
Test.S1.release() ; }}
public class P3 extends Thread {
public void run()
{
try{
Test.S1.acquire();

1
 }
catch(Exception e)
{}
Test.x=Test.x+3;
Test.S2.release();
Test.S1.release();
}}

Donner les valeurs finales possibles de la variable x. Justifier votre réponse.

Exercice 2 :
Il s'agit de garantir à un processus qu'il sera le seul à un instant donné, à exécuter une portion
critique de son code. En d'autres termes, plusieurs processus exécutent le programme suivant
en parallèle :
class P extends Thread
{
while (true)
{
< section non critique >
(* essayer d'entrer en section critique *)
< section critique >
(* sortir de la section critique *)
}
}

Soit une solution qui utilise les trois variables globales flag[0] : boolean, flag[1] : boolean,
token : 0..1, initialisées respectivement à false, false, 0.

class P0 extends Thread

{
Public void run()
{
while (true )
{
< section non critique >
flag[0] := true;
while (token != 0)
{
While ( flag[1] = =true)
{
}
token = 0
}
< section critique >
flag[0] = false;
}
}}

class P1 extends Thread

{
public void run()
{
while (true )

2
 {
< section non critique >
flag[1] := true;
while (token != 1)
{
While ( flag[0] = =true)
{
}
token = 1
}
< section critique >
flag[1] = false;
}
}}

Montrez, en donnant une exécution (à chaque instant, un seul des processus effectue une
action) possible de ce programme, que cette solution est fausse du fait qu'il est possible que
les deux processus soient simultanément en section critique.

Instant Processus P0 Processus P1 Flag[0] Flag[1] token

0 (initil) False False 0
1
2
3
4
5
6
7
8
9
10
11

Exercice 3 :
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 << P<<N.

Développez une solution à ce problème en utilisant les sémaphores.