31/12/2021
Université Mohammed V- Rabat
École Mohammadia d'Ingénieurs
Département Génie Informatique
Filière Informatique
SYSTÈMES D'EXPLOITATION
Mr N. EL Faddouli (elfaddouli@[Link])
Mme Z. Bakkoury (bakkoury@[Link])
2021-2022
Plan du cours
Introduction et Rappels
Gestion des processus: Synchronisation avec attente active
– Définitions et rappels
– Algorithmes avec attente active
Gestion des processus: Synchronisation sans attente active
– Les sémaphores
– Les moniteurs
– L'interblocage (Dead-lock)
Gestion de la mémoire
– Définitions et rappels
– La mémoire virtuelle
Les entrées/Sorties
EMI / Département Génie Informatique/ Système d’exploitation II 2
1
31/12/2021
Thread en Java : Création
• Par héritage de la classe [Link]. Deux objets de cette classe peuvent
être utilisés pour lancer deux processus qui s’exécuteront en concurrence.
• En implémentant l’interface [Link].
import [Link];
class extends Thread // la classe qui représente le thread.
{ String txt; int attente; // La chaîne à afficher et délai d'attente (ms)
public TAfficher (String t, int p) { txt = t; attente = p;} / /Constructeur
private void Imprimer ()
// la classe implémente Runnable
{ for (int i=0; i<[Link](); i++) // Parcourt de la chaîne txt
class TAfficher implements Runnable
{[Link]([Link](i) +" "); //caractère txt[i]
{ String txt; int attente;
try { sleep(attente); // le thread s'endort
public TAfficher (String t, int p) { ....}
} catch(InterruptedException e)
private void Imprimer ()
{[Link]([Link]());};
{ ......}
}}
@Override
@Override
public void run()
public void run() // méthode contenant le code du thread
{ imprimer(); }
{ imprimer(); }
}
} EMI / Département Génie Informatique/ Système d’exploitation II 86
Thread en Java: Démarrage
• Instanciation de la classe contenant le code du thread (run()).
• Appel de la méthode start() héritée de la classe Thread.
public class TestThread
{
static public void main(String args[])
{
TAfficher A = new TAfficher("Bonjour", 100); //Création du premier thread A
TAfficher B = new TAfficher ("Au revoir", 200); //Création du deuxième thread B
// Démarrage de l'exécution du premier thread exécution de la méthode run()
[Link]();
// Démarrage de l'exécution du deuxième thread
Thread ta = new Thread(A);
Thread tb = new Thread(B);
[Link](); [Link]();
start() exécution en concurrence [Link]();
run() l'exécution séquentielle
}
EMI / Département Génie Informatique/ Système d’exploitation II 87
2
31/12/2021
Thread en Java: Exclusion mutuelle (1)
• Dans une classe représentant un moniteur, le mot clé synchronized:
indique qu'une méthode constitue une section critique à exécuter en
exclusion mutuelle dans le moniteur.
• Un objet de type moniteur doit être partagé par plusieurs threads, il peut
être un attribut static dans la classe des threads.
class MoniteurImpression //Le moniteur
{ //méthode d'affichage de la chaîne t avec un délai d'attente d
synchronized public void Imprimer(String t, int d)
{ for (int i=0; i<[Link](); i++)
{ [Link]([Link](i));
try { [Link]().sleep(d); // Le thread appelant s'endort
} catch (InterruptedException e) {[Link]([Link]());};
}
}}
EMI / Département Génie Informatique/ Système d’exploitation II 88
Thread en Java: Exclusion mutuelle (2)
• Les sections critiques dans les threads doivent devenir des fonctions dans un
moniteur (classe).
• Utilisation du mot clé synchronized: indiquer qu'une méthode constitue une
section critique à exécuter en exclusion mutuelle.
• Une seule méthode synchronisée est exécutée à un instant donné par un thread.
• Les autres méthodes non synchronisées sont exécutées sans exclusion
mutuelle.
class MoniteurImpression //Le moniteur
{ synchronized public void Imprimer(String t, int d)
{ for (int i=0; i<[Link](); i++) public void Imprimer(String t, int d)
{ [Link]([Link](i)); { synchronized (this) {
try { // code de la méthode Imprimer
}
}
[Link]().sleep(d);
} catch (InterruptedException e) {[Link]([Link]());};
}
}} EMI / Département Génie Informatique/ Système d’exploitation II 89
3
31/12/2021
Thread en Java: Exclusion mutuelle (3)
• Les threads de même classe peuvent partager un moniteur via un
attribut statique de type moniteur dans leur classe.
class TAfficher extends Thread // La classe des threads.
{ String txt; int attente; // chaîne à afficher et délai d'attente
static MoniteurImpression M = new MoniteurImpression( ); // attribut static
public TAfficher (String t, int p) { txt = t; attente = p;} / /Constructeur
public void run()
{ for (int i=1; i<3; i++) // affichage de txt 3 fois avec la méthode Imprimer
{ [Link] (txt, attente);
// attente de 50ms après chaque accès au moniteur
try{ sleep(50); } catch (InterruptedException e) {};
}
}}
EMI / Département Génie Informatique/ Système d’exploitation II 90
Thread en Java: Attente explicite (1)
• Un moniteur possède une condition anonyme utilisée avec wait() et
notify()
• wait() : le thread appelant est bloqué jusqu'à ce qu'un autre thread
appelle notify(). wait() permet à d'autres threads d'exécuter des
méthodes synchronisées du même objet moniteur.
• notify() : permet de débloquer un thread bloqué par wait().
o Si un thread T1 appelle wait() dans une méthode synchronisée, via
l'objet moniteur O, il sera bloqué dans la condition anonyme.
o Un autre thread T2 ne pourra débloquer T1, avec notify(), qu'en
appelant une méthode synchronisée (contenant notify()) du même
objet moniteur O.
L'objet O doit être partagé par T1 et T2.
• wait() et notify() (héritées de la classe Object) ne doivent s'utiliser que dans
des méthodes synchronisées.
EMI / Département Génie Informatique/ Système d’exploitation II 91
4
31/12/2021
Thread en Java: Attente explicite (2)
class MoniteurProdCons
{ String tampon; boolean Vide = true;
synchronized void Produire(String m)
{ while(!Vide) { [Link]("Producteur attend");
try { wait(); } catch (InterruptedException e) { }
}
[Link]("Message Produit : "+ m); tampon = m; Vide=false;
notify();
}
synchronized void Consommer()
{ while (Vide) { [Link]("Consommateur attend");
try { wait(); } catch (InterruptedException e) {}
}
[Link]("Message Consommé : "+ tampon); Vide=true;
notify();
} }
EMI / Département Génie Informatique/ Système d’exploitation II 92
Thread en Java: Attente explicite (3)
class Producteur extends Thread{
MoniteurProdCons M;
public Producteur (MoniteurProdCons t)
{ M = t; }
public void run() { [Link]("message1");
[Link]("message2");
try { sleep(100); } catch(InterruptedException e) { }
[Link]("message3");
}
}
class Consommateur extends Thread {
MoniteurProdCons M;
public Consommateur(MoniteurProdCons t) { M = t; }
public void run() { [Link](); [Link](); [Link]();}
}
EMI / Département Génie Informatique/ Système d’exploitation II 93
5
31/12/2021
Thread en Java: Attente explicite (4)
public class TestThread
{
public static void main(String argv[])
{
MoniteurProdCons M = new MoniteurProdCons();
Producteur P = new Producteur(M);
Consommateur C = new Consommateur(M);
[Link]();
[Link]();
}
}
EMI / Département Génie Informatique/ Système d’exploitation II 94
Thread en Java: Les conditions (1)
Le package [Link] contenant des classes et des
interfaces pour créer des verrou et des variables de type condition.
La classe ReentrantLock représente des verrous d'exclusion mutuelle
et permet de créer des variables de type condition.
L'interface Condition représente une variable de type condition
associée à un verrou. Elle permet de suspendre un thread et le mettre
en attente (wait) jusqu'à ce qu'il soit notifié par un autre thread. Le
thread supendu libère automatiquement le verrou de la variable
condition.
Un thread doit acquérir le verrou d'une condition pour l'utiliser (faire un
wait) et le libérer par la suite
EMI / Département Génie Informatique/ Système d’exploitation II 95
6
31/12/2021
Thread en Java: Les conditions (2)
public class ProdCons{
final Lock verrou= new ReentrantLock();
final Condition plein = [Link]();
final Condition vide = [Link]();
final Object[ ] tampon; int rind, wind, count, n;
public ProdCons(int n) { this.n = n; count=0;rind=wind=0;
tampon= new Object[n];
}
public void put(Object x) throws InterruptedException {
[Link]();
try { while (count == n) [Link]();
tampon[wind] = x; wind = (wind + 1) % n; count++;
[Link]();
} finally {
[Link]();
}
}
EMI / Département Génie Informatique/ Système d’exploitation II 96
Thread en Java: Les conditions (3)
public Object take() throws InterruptedException {
[Link]();
try {
while (count == 0) [Link]();
Object x = tampon[rind];
rind = (rind+ 1)% n; count--;
[Link]();
return x;
} finally {
[Link]();
}
}
}
EMI / Département Génie Informatique/ Système d’exploitation II 97
