Programmation Système

en .NET

V7

Structure Interne de Windows

Page 1
 Introduction
Windows depuis 2000 utilise la POO pour représenter et
manipuler des objets physiques et abstraits

Les objets :
 Définition
• Un objet est une instance en phase d'exécution d’un type
d’objet défini de façon statique
 Caractéristique
• Un type d’objet = classe d’objet
• héritage
• pas de polymorphisme
Exemple d’objets dans Windows 2003 Server
 Processus
 Thread
 Fichier
 Mutex
 Sous système Win 32
3 D. Bourget

Types d’objets
L’exécutif Windows 2003 utilise trois sortes d’objets
 les objets de l’exécutif
 les objets du noyau
 Les objets du mode sécurité
Les objets de l’exécutif :
 Un processus est une occurrence du type objet "Processus"
• System.Diagnostics.Process,
 Un fichier est une occurrence du type objet fichier
• System.IO.StreamReader, System.IO.Stream, etc
 Un Mutex est une occurrence du type objet Mutex
• System.Threading.Mutex
 Un Thread est une occurrence du type objet "Thead«
• System.Threading.Thread, System.Threading.ThreadPool
 Etc etc

4 D. Bourget

Page 2
 Gestionnaire d’objets
Gestion des objets :
 Mécanisme de comptage des objets
 Mise en place d’un service au niveau de la rétention d’objets
 Prendre en compte les contraintes d’environnement.
 Regroupement des fonctions de protection des objets
 Intégration en tant qu’objet des fichiers, périphériques
Le gestionnaire d’objets Windows exécute les fonctions
suivantes :
 Allocation de mémoire
 Attribution d’un descripteur de sécurité
 Création d’une structure de répertoire d’objet
 Gestion de cette structure
• les objets sont stockés dans cette structure
 Gréation d’un Handle d’objet
• Un handle d’objet est un index dans une table d’objets
spécifique à un processus
 Retour à l’appelant

5 D. Bourget

Gestionnaire d’objets
Mode de fonctionnement :
 Tous les processus disposent d’un handle sur un objet.
 Le thread utilisera cet handle
• thread d’un processus
 Les handles sont des pointeurs indirects sur les ressources
du système
 Chaque fois qu’un thread utilise un handle le gestionnaire
d’objet vérifie les droits d’accès
 Surveillance des objets temporaires (GC)
 Surveillance de l’utilisateur des ressources
 Le moniteur de référence de la sécurité est automatiquement
appelé lorsqu’un processus ouvre un handle sur un objet
 Par la suite c’est le gestionnaire d’objets qui assure la
cohérence au niveau de la sécurité.

6 D. Bourget

Page 3
 Description d’un objet

Nom de l’objet
Répertoire de l’objet
En tête de Descripteur de sécurité
l’objet Charges de quota
Compteur de handles ouverts
Bases de données de handles ouverts
permanent ou temporaire
Mode noyau ou mode utilisateur
pointeur sur les type de l’objet

Corps de
l’objet
7 D. Bourget

Gestion des objets

Attribut d'un objet
 Nom de l’objet
 Répertoire de l’objet
 Descripteur de sécurité
 Nom de l’objet type
 Types d’accès
 Possibilité de synchronisation
 Paginable ou non paginable
Services Génériques d’un objet
 Fermer
 Dupliquer
 Interroger l’objet
 Interroger la sécurité
 Changer la sécurité
 Attendre un objet
 Attendre plusieurs objets
8 D. Bourget

Page 4
 Types d’objet

Objet

Processus
Objet-type
de processus
Objet

Processus

Objet

Processus
9 D. Bourget

Processus Windows

accès accordé objets disponibles

Processus Héritage
1

Thread 1
Descripteur 1
Descripteur 2
Descripteur 3 Thread 2

Descripteur 4

Fichier 1
Table d’objets
10 D. Bourget

Page 5
 Partage d’un objet
Processus
1

thread 1

Processus
événement 2

thread 1
Table d’objets
du processus 1

Table d’objets
du processus 2

11 D. Bourget

Processus et Threads

Page 6
 Processus
Un processus est constitué :
 D'un programme exécutable (code + données)
 D'un espace d'adressage privé
 De ressources systèmes
• mutex
• fichiers
• ports de communication
• moniteur
 Au moins Un "fils" d'exécution (Thread)

13 D. Bourget

Un processus et ses ressources

Description de l’espace virtuel
Jeton d’accès

Processus Objets
1 disponibles

thread
1
thread2
fichier

Table d’objets
du processus 1

14 D. Bourget

Page 7
 Thread
Description d'un thread :
 Un ID unique
 Contenu de l ’ensemble des registres (état du
processeur)
 Deux piles :
• mode utilisateur
• mode noyau
 Une zone privée de données utilisée par les sous-
systèmes, les bibliothèques de liaison dynamique (DLL)
Chaque thread peut être ordonnancé indépendamment
sur le processeur (fiber), peu utilisé.
Un thread se trouve dans l'espace d'adressage virtuel
d'un processus
Attention à partir de Windows Vista, Windows 7,
Windows 2008 server R2 il existe un mode sécurité
15 D. Bourget

Domaines d'application (.NET)

Un domaine d'application (AppDomain) est un
environnement dans lequel s'exécute les
applications
Chaque application s'exécute dans son
domaine propre
Ne pas confondre les domaines d'application
avec les Assemblys (dll, exe, ..), les
processus (un conteneur) et les threads
(l'unité de base d'exécution)

16 D. Bourget

Page 8
 Processus

Gestion des processus

Un processus en .NET est vu comme un
conteneur
Dans un conteneur plusieurs "domaines
d'application" peuvent s'exécuter
Le Framework .NET fournit la classe "Process"
 Via espace de noms "System.Diagnostics"
Les fonctionnalités de cette classe
 Démarrage, arrêt, contrôle, surveillance des processus
 Obtenir la liste des processus en activité
 Accès au processus système
 Les modules chargés en mémoire
 Les threads en fonctionnement
 La quantité mémoire

18 D. Bourget

Page 9
 La classe "Process"
Un élément de la classe "Process" fournit l'accès à un
processus en cours d'exécution
On peut considérer qu'un processus est une
application en cours d'exécution.
Il ne faut pas confondre un processus et un thread
(appelé également "processus léger"). Un thread aura
pour fonction d'exécuter une partie du code du
processus.
Les fonctionnalités d'un objet instance de la classe
"Process" sont :
 Démarrer un processus
 Arrêter un processus
 Contrôler un processus ou plusieurs processus
 Surveiller les processus

19 D. Bourget

La classe Process
Un composant de la classe "Process" permet
l'accès aux processus système.
Différentes informations sont accessibles via
le composant issu de la classe "Process".
Les informations accessibles sont :
 les threads composants le processus (au moins
un)
 les modules chargés (fichiers .dll et .exe)
 les informations sur la quantité de mémoire utilisée
par le processus, le PID du processus
 les informations au niveau du groupe de processus
auquel le processus appartient

20 D. Bourget

Page 10
 La classe Process
Propriétés publiques
 Id : Obtient l'identificateur unique du processus associé.
 HasExited : Obtient une valeur indiquant si le processus
associé s'est terminé.
 ProcessName : Obtient le nom du processus.
 StartInfo : Obtient ou définit les propriétés à passer à la
méthode Start de Process.
 Threads : Obtient le jeu des threads en cours d'exécution
dans le processus associé. …
Méthodes publiques
 Close : Libère toutes les ressources associées au
processus
 Kill : Arrête immédiatement le procesus associé.
 Start : Lance une ressource processus. …
21 D. Bourget

Méthode : Start()
Start() est une méthode surchargée de la
classe "Process".
Méthodes statiques
 public static Process Start(string);
• nom d'une application
 public static Process Start(string, string);
• nom d'une application + arguments ligne de
commande
 public static Process Start(ProcessStartInfo);
• le nom d'un document d'application
Méthode membre
 public bool Start();
• Nécessite l'utilisation de la propriété "StartInfo"

22 D. Bourget

Page 11
 Création d'un processus : version 1

23 D. Bourget

Résultat version 1

24 D. Bourget

Page 12
 La propriété StartInfo
Arguments
 Les arguments à passer à la commande
FileName
 Nom du fichier
Verb
 Commande à exécuter si c'est un fichier non
exécutable. Exemple" Print fic.txt". …

25 D. Bourget

Création d'un processus : version 2

26 D. Bourget

Page 13
 Résultat version 2

27 D. Bourget

Création d'un processus : version 3

28 D. Bourget

Page 14
 Résultat version 3

29 D. Bourget

Autres Exemples
Ouvrir un Navigateur
System.Diagnostics.Process.Start("http://www.enst-
bretagne.fr");
Ouvrir un gestionnaire de courrier
System.Diagnostics.Process.Start("mailto:Daniel.bourget
@enst-bretagne.fr");

30 D. Bourget

Page 15
 La classe "ProcessStartInfo()"
Cette classe est souvent utilisée en même
temps que la classe "Process"
Elle permet l'accès à des informations sur le
processus, elle est beaucoup plus riche que
les informations associées à la propriété
"StartInfo" de la classe "Process".
Elle permet un meilleur contrôle sur le
processus démarré.

31 D. Bourget

Les constructeurs de "ProcessStartInfo"

public ProcessStartInfo();
 Initialise une nouvelle instance de la classe
"ProcessStartInfo"
public ProcessStartInfo(string);
 Initialise une nouvelle instance de la classe
ProcessStartInfo et précise le nom de l' application
ou du document avec lequel démarrer le
processus.

ProcessStartInfo(String, String);
 Le premier argument est identique à celui du
constructeur précédent
 Le second argument précise le jeu d'arguments de
la ligne de commande à passer à l'application.
32 D. Bourget

Page 16
 Propriétés de "ProcessStartInfo"
 String Arguments
• Les arguments de la ligne de commande
 Bool CreateNoWindows
• Exécution ou non du processus dans une autre
fenêtre
 String Filename
• Nom de l'exécutable
 ProcessWindowStyle WindowStyle
• Le style de la fenêtre (Hidden, Maximized, Minimized,
Normal)
 String WorkingDirectory
• Le répertoire dans lequel sera démarré le processus
 Etc etc

33 D. Bourget

ProcessStartInfo : membres, propriétés

Pas de méthode ni de propriété statique

34 D. Bourget

Page 17
 Exemple
–

Ouvrir une application

System.Diagnostics.Process p;
System.Diagnostics.ProcessStartInfo psi;
psi = new System.Diagnostics.ProcessStartInfo();
psi.FileName = "NotePad.exe";
psi.Arguments = "data.txt";
psi.WorkingDirectory = "C:\";
psi.WindowStyle =
System.Diagnostics.ProcessWindowStyle.Normal;
p = System.Diagnostics.Process.Start(psi);

35 D. Bourget

Exemple (2)
Autre solution possible
 Process p = new Process();
 p.StartInfo = new ProcessStartInfo();
 p.StartInfo.FileName = "NotePad.exe";
 p.Start();
Encore d'autre possibilité
 Process p = Process.Start("NotePad.exe");

36 D. Bourget

Page 18
 Classe "Process" (suite)
Les informations associées à un processus
sont toujours liées à la propriété "StartInfo"
Attention cette propriété contient un objet de
type ProcessStartInfo
La méthode Start() de la classe "Process"
peut lever trois exceptions :
 InvalidOperationException
 Win32Exception
 ObjectDisposeException

37 D. Bourget

Arrêter un processus
Il existe deux manières pour terminer un
processus
 Kill()
 CloseMainWindow()
La méthode Kill() a pour vocation d'arrêter
immédiatement un processus avec perte
éventuellement d'informations
 p.Kill();
La méthode CloseMainWindow() arrête
proprement un processus en gérant notamment
tous les messages en attente
 p. CloseMainWindow()
Attention ne pas confondre avec la méthode
Close() qui ne libère que les ressources
associées au processus
38 D. Bourget

Page 19
 Arrêter un processus : principe
Pour arrêter un processus les actions
possibles à mettre en œuvre sont :
 Appelez la méthode GetProcessesByName ou
GetProcessById pour récupérer le processus à
arrêter.
 Appelez soit :
• CloseMainWindow
• Kill
 Utiliser la propriété HasExited pour vérifier si le
processus associé à un Process est encore ou non
en exécution. Il est possible également d'utiliser
ExitTime qui donne l'heure à laquelle le processus
associé s'est terminé.

39 D. Bourget

Surveillance d'un processus

Toutes les informations relatives au processus
sont définies au niveau des propriétés du
processus dans la classe "Process"
La méthode Refresh() remet à jour les propriétés
d'un processus (mécanisme non dynamique)
Les propriétés d'un objet processus sont :
 Int BasePriority, bool EnableRaisingEvents, int
ExitCode, DateTime ExitTime, Int PtrHandle, int
HandleCount, bool HasExited, int Id, string
MachineName, ProcessModule MainModule, int
PagedMemorySize, string ProcessName, DateTime
StartTime, ……

40 D. Bourget

Page 20
 Threads

Les threads
Les threads sont l'unité de base lors de
l'exécution d'un processus
Le CLR .NET est multi-threadé par défaut
(historique dans Windows NT)
Un processus peut créer un ou plusieurs
threads pour exécuter des portions de code
différents
Deux types de gestion des threads du
namespace System.Threading
 Utilisation de la classe ThreadPool
• Ensemble restreint mais efficace
 Utilisation de la classe Thread.
Il ne faut pas oublier que la majeure partie du
42 D. Bourget
temps un thread est en attente

Page 21
 Les threads
Chaque thread gère
 Un mécanisme d'exceptions
 Une priorité de planification
 Un ensemble de structures pour enregistrer le
contexte d’un thread.
Par définition le contexte d‘un thread
comprend:
 Ensemble d’informations nécessaire à la reprise
d’exécution d’un thread
 Le jeu des registres du CPU
 La pile du thread
 L’espace d'adressage du processus dont le thread
fait parti.
43 D. Bourget

Les threads
Les threads sont définis dans la classe
System.threading.Thread
Les priorités d'un threads sont :
 Highest
 AboveNormal
 Normal
 BelowNormal
 Lowest
Fonctionnement :
 Il est impossible de passer des paramètres au
démarrage d'un thread. On utilise les propriétés
pour lui envoyer des valeurs

44 D. Bourget

Page 22
 Les threads : fonctionnement

Les threads posent des problèmes de

fonctionnement au niveau du
mécanisme d'inter-threading
En effet toutes les Windows Forms
(WinForm) utilisent des threads. Le
traitement peut-être plus au moins
lourd.
Toutes les applications WindForms
s'exécute dans le thread UI (User
Interface), le thread par défaut.
45 D. Bourget

Les threads : fonctionnement

Il y aura blocage de l'application si on

utilise également le thread UI à des fins
personnelles.
En réalité, en .Net, les opérations
cross-threads sont interdites.
C'est-à-dire qu'un Thread ne peut pas
modifier les propriétés d'objet qu'un
autre Thread a créé.
Exemple :
 un Thread qui voudrait modifier le texte
d'un bouton d'une Windows Forms
46 D. Bourget

Page 23
 Inter threading
Il est plus simple d'utiliser les méthodes
statiques suivantes quand on n'a pas de
paramètre à passer
 cas synchrone
– Control.Invoke(unDelegate, objet[], objet[])
 Cas asynchrone
• Le couple
– Control.BeginInvoke(unDelegate)
Control.EndInvoke(IAsyncResult)

47 D. Bourget

InterThreading
using System.Windows;
using System.Threading;

namespace Wpf_Interthreading
{
/// Logique d'interaction pour MainWindow.xaml
public partial class MainWindow : Window
{
private Thread th;
private void LanceMethode()
{
textBox.Text = "Information";
}

public MainWindow()
{
th = new Thread(new ThreadStart(LanceMethode));
th.Start();
InitializeComponent();
}
}
}
48 D. Bourget

Page 24
 Comment récupérer l’erreur
Modifier le type du projet
 Mettre de type « Appplication Console »

49 D. Bourget

InterThreading : Solution 1
namespace Projet_45a
{
public partial class Form1 : Form {
private Thread th;
private delegate void leDelegate(string str);

public Form1() {
InitializeComponent();
th = new Thread(new ThreadStart(methodeThread));
th.Start();
InitializeComponent();
}

private void LanceMethode2(string str) {

textBox.Text = str;
}

private void methodeThread() {

this.Dispatcher.Invoke(
new leDelegate(LanceMethode2, "Information");
}
50 D. Bourget} }

Page 25
 Inter threading : solution 2
using System;
using System.Drawing;
using System.Windows.Forms;
using System.Threading;

namespace Projet_45 {
public partial class Form1 : Form {
private Thread th;

private void LanceMethode() {

this.Dispatcher.BeginInvoke(DispatcherPriority.Normal,
(threadStar)delegate()
{
textBox.Text= " Information " ;
} );

public Form1() {
th = new Thread(new ThreadStart(LanceMethode));
th.Start();
InitializeComponent();
}}}
51 D. Bourget

Inter threading : solution 3

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Threading;

namespace Projet_45 {
public partial class Form1 : Form {
private Thread th;

private void LanceMethode(string str) {

this.Dispatcher.BeginInvoke(DispatcherPriority.Normal,
(threadStar)delegate()
{
textBox.Text= str ;
} );

public Form1() {
th = new Thread(new ThreadStart(() => LanceMethode("test"));
th.Start();
InitializeComponent();
}}}
52 D. Bourget

Page 26
 Inter threading : autre solution
Background Worker
 La classe "BackgroundWorker" permet d'exécuter
une opération sur un thread séparé
using System.ComponentModel;

// Declaration background worker:

private readonly BackgroundWorker worker = new BackgroundWorker();

//Définir un évènement
worker.DoWork += worker_DoWork;

Private void worker_DoWork(object sender, DoWorkEventArgs e) {

// corps de la tâche

//Appel asynchrone du worker

worker.RunWorkerAsync();

53 D. Bourget

Background Worker
Description
 3 attributs
• Stop manuel ?
• Donne l'avancement ?
• Attend d'être arrêté
 3 méthodes
• RunAsync pour débuter,
• CancelAsync pour stopper,
• IsBusy pour savoir son état
 4 événements
• La tâche,
• Le rapport de l’avancement de la tâche,
• La fin de la tâche,
• La libération du worker

54 D. Bourget

Page 27
 Inter threading
Comment résoudre ce problème ?
 Utilisation des délégations synchrones
ou asynchrones.
 Intercepter les appels incorrects sur le thread
Control.CheckForIllegalCrossThreadCalls = false.
Attention cela ne fonctionne pas toujours et c’est
dangereux.
Les délégations synchrones et asynchrone
 Délégation synchrone
• Control.Invoke(delegate, object[])
 Délégation asynchrone
• Le couple : Control.BeginInvoke(delegate,object[]) /
Control.EndInvoke(IAsyncResult)

55 D. Bourget

Application Domaine
Le .NET Framework permet de diviser un
processus dans des sous processus
managés, nommés domaines d'applications
Un domaine d’application représente un
environnement isolé dans lequel s'exécute
les applications. La classe définissant ce
composant se nomme System.AppDomain.
Un ou plusieurs threads managés ont la
possibilité de s'exécuter dans un ou plusieurs
domaines d'applications et ceci à l’intérieur
d’un même processus non managé.

56 D. Bourget

Page 28
 TreadSpool
Il n’est pas possible de gérer totalement le
contrôle de la vie d'un thread
Le système est omniprésent au niveau de la
gestion des threads
Les méthodes, uniquement statiques, de la
classe TreadSpool :

57 D. Bourget

Classe TreadSpool()
Les méthodes de la classe TreadSpool :
 GetMAxThreads()
• Nombres maximum de requêtes en attente sur la file
d’attente
– public static void GetMaxThreads( out int workerThreads,
out int completionPortThreads );
 GetAvailableThreads()
• Récupère le nombre de requêtes que l'on peut ajouter à la
file d'attente avant d'attendre GetMAxThreads()
– public static void GetAvailableThreads( out int
workerThreads, out int completionPortThreads );

58 D. Bourget

Page 29
 Classe TreadSpool()
Les méthodes de la classe TreadSpool (suite)
 QueueUserWorkItem()
• Ajout d'une nouvelle méthode dans la file d'attente. La
méthode s'exécute lorsqu'un thread du pool devient
disponible.
– public static bool QueueUserWorkItem( WaitCallback
callBack );
– public static bool QueueUserWorkItem( WaitCallback
callBack, object state );
• Attention il est obligatoire de définir la méthode
référencée comme
– Void laMéthodeRéférencée (object o)
 RegisteredWaitHandle
• Gére les mécanismes de synchronisation
– Change notification, Console input, Event, Job, Memory
resource notification , Mutex, Process, Semaphore, Thread,
Waitable timer
– public static RegisteredWaitHandle
RegisterWaitForSingleObject( WaitHandle waitObject,
59 D. Bourget WaitOrTimerCallback callBack, object state, int
millisecondsTimeOutInterval, bool executeOnlyOnce );

La classe Thread()
Manipulation plus fine mais plus complexe des
threads
Création d'un thread
 ThreadStart thd = new ThreadStart (uneMéthode);
 Thread unThread = new Thread(thd);
 void uneMéthode() { …..};
Attention un thread ayant fini son exécution se
termine normalement.
Stopper l'exécution d'un thread
 unThread.Sleep(3000) /* 3 secondes */
Arrêter l'exécution d'un thread
 unThread.Abort()
 Etc etc
60 D. Bourget

Page 30
 La classe Thread()
System.Threading.Thread

61 D. Bourget

Le constructeur de Thread()
Ce constructeur à pour but d’initialiser une nouvelle
instance de la classe Thread.
Attention l’argument du constructeur de cette classe
est de type ThreadStart
 public Thread(TheardStart départ);
En fait TheardStart est un délégué qui spécifie la
méthode qui sera lancée lors de l’exécution du thread
 public delegate void ThreadStart();
 L'exécution du thread ne commence pas tant que la
méthode Start n'est pas appelée
Exception
 ArgumentNullException
• Exception levée lorsqu'une référence null est passée à une
méthode

62 D. Bourget

Page 31
 La classe Thread()
IsAlive (attribut)
 Obtient une valeur indiquant l'état de l'exécution du
thread actuel
Abort (2 Surcharges)
 public void Abort();
• Cette méthode déclenche ThreadAbortException dans le
thread ou abord apparaît.
• Attention cet appel de cette méthode arrête
généralement le thread.

63 D. Bourget

La classe Thread()
Join (3 Surcharges)
 public bool Join();
• Bloque le thread appelant jusqu'à l'arrêt d'un thread.
• C’est-à-dire join() attend un tread pour terminer
 public bool Join(int);
• Bloque le thread appelant jusqu'à l'arrêt d'un thread ou
l'écoulement de la durée spécifiée, en nombre de
millisecondes à attendre avant l'arrêt du thread.
Sleep (2 Surcharges, méthodes statiques)
 static void Sleep(int);
• Bloque immédiatement le thread en cours pendant le
nombre spécifié de millisecondes.
 Thread.Sleep(Timeout.Infinite)
• entraîne la mise en veille d'un thread jusqu'à son
interruption par un autre thread qui appelle
Thread.Interrupt ou jusqu'à son abandon par
Thread.Abort.
64 D. Bourget  Un thread ne peut pas appeler Sleep sur
un autre thread

Page 32
 La classe Thread()
Start
 public void Start();
• Provoque le changement de l'instance en cours du
thread qui est dans l’état Running
 Les exceptions levées
• ThreadStateException
– Le thread a déjà été démarré
• SecurityException
• OutOfMemoryException.
• NullReferenceException
Suspend Suspend
 public void Suspend();
• Suspend le thread
• Cette méthode n’a aucun effet s'il est déjà
65 D. Bourget suspendu

Exemple simple : nombres premiers

66 D. Bourget

Page 33
 Commentaires (1)
Style de programmation pour créer un thread :
 1ère manière

 2ième manière

Il est possible d’endormir un thread pendant

un certain temps (temps défini en
millisecondes).
 Thread.Sleep(50);

67 D. Bourget

Autre exemple

68 D. Bourget

Page 34
 IsAlive
Obtient une valeur indiquant l'état de l'exécution du
thread actuel.
 Utilisation
while (!unThread.IsAlive);
L’utilisation de la méthode join() pour un thread
entraîne nécessairement une attente par le thread
principal d’un temps :
 du à l'expiration de ce dernier
 d'une durée spécifiée

69 D. Bourget

Vie d'un thread

Les états d'un thread
 Ready (en attente d'être exécuté)
 Standby (le prochain à exécuter)
 Running
 Waiting
 Transitoire (prêt â être exécuté, en attente de
ressources)
 Terminé (fin mais possibilité de réinitialiser)
Deux classes de priorité
 Priorité variable (0 .. 15)
 Temps réel (16 .. 31)
 Fonctionnement
• Une file d'attente nommée "File d'attente "prêt" du
répartiteur"
• La plupart des threads du système appartient à la classe
priorité variable

70 D. Bourget

Page 35
 Interruption de thread
Un thread peut suspendre et reprendre
l'exécution d'un autre thread en utilisant les
méthodes suivantes :
 SuspendThread
 ResumeThread.
Attention ces deux méthodes ne peuvent pas
êtres utilisées comme points de
synchronisation.
Les deux appels à Sleep
 Thread.Sleep (int temsMiliSeconce)
 Thread.Sleep(Timeout.Infinite)
• Thread.Interrupt ou Thread.Abort.

71 D. Bourget

Interruption
Thread.Suspend.
 Lorsqu'un thread appelle Thread.Suspend sur lui-même,
cet appel est bloquant jusqu'à ce que le thread soit repris
par un autre thread.
 Lorsqu'un thread appelle Thread.Suspend sur un autre
thread, l'appel est à ce moment un appel non bloquant
mais entraîne la suspension de l'autre thread.
Thread.Resume
 Reprend un thread qui a été suspendu
 Ceci est indépendant du nombre d'appels à
Thread.Suspend qui a été réalisés sur l’objet.

72 D. Bourget

Page 36
 Interruption
Le cas d'appel à Thread.Sleep(Timeout.Infinite)
 Cet appel entraîne la mise en veille d'un thread jusqu'à
son interruption. Cette interruption par un autre thread
qui appelle Thread.Interrupt ou jusqu'à son abandon par
Thread.Abort.
Thread.Interrupt
 Interrompt un thread dont l'état est WaitSleepJoin.
 Cet appel interrompt donc l’attente d’un thread arrêté. Il
lève une exception ThreadInterruptedException dans le
thread de destination.
Thread.Abort
 Déclenche l'exception ThreadAbortException sur le
thread.

73 D. Bourget

Les attributs utiles

Généralement les propriéts que l'on utilisent le
plus souvent sont :
 string Name
• le nom du thread
 •bool IsAlive
• indique si le thread est en cours d'exécution ou non.
 Thread CurrentThread
• Renseigne sur le thread en exécution

74 D. Bourget

Page 37
 Les méthodes utiles
Généralement les méthodes que l'on utilisent le
plus souvent sont :
 • Start(), Start(object obj) :
• Exécution asynchrone du thread•
 Abort(), Abort(object obj) :
• Arrêt brutal d'un thread pour terminer de force un thread.
 Join() :
• le thread T1 qui exécute T2.Join est bloqué jusqu'à la fin
de l’exécution de T2.
 • Sleep(int n)
• le thread est suspendu n millisecondes.

75 D. Bourget

Synchronisation, section critique

A l'aide de verrou
lock()
{
// début de la section critique
}
A l'aide des moniteurs
Moniteur.Enter(this)
// section critique
Moniteur.Exit(this)

76 D. Bourget

Page 38
 Class ReadWriterLock
Cette classe simplifie le mécanisme de
verrouillage d'objet
Liste des méthodes ::
 AcquireReaderLock()
 RealeaseReaderLock()
 AcquireWriterLock()
 ReleaseWriterLock()

77 D. Bourget

Exemple : ReaderWriterLock
namespace Projet_46
{
class Program
{
private static ReaderWriterLock rwl;

static void Main(string[] args)

{
rwl = new ReaderWriterLock();

rwl.AcquireReaderLock(Timeout.Infinite);

// accès à une valeur protégée

rwl.ReleaseLock();
}}}

78 D. Bourget

Page 39
 Les autres classes
Classe Interlocked
 Utiliser pour simuler les sémaphores
 InterlockedIncrement( ref i)
Classe Mutex
 Mutex.WaitOne()
 Mutex.Release()
Classe AutoResultEvent
Classe ManualResetEvent
Classe Monitor
BackgroundWorker
 System.ComponentModel

79 D. Bourget

Classe Mutex
Permet de contrôler les accès aux sections
critiques pour une application donnée.
Ne pas confondre la clause lock avec les
objets instances de la classe Mutex
Les différences entre la clause lock et la
classe Mutex sont :
 lock permet de la synchronisation des threads
d'une même application
 • la classe Mutex permet la synchronisation des
threads de plusieurs applications.

80 D. Bourget

Page 40
 La classe Mutex
Les méthodes les principales :
 public bool WaitOne()
• Bloque le thread actuel jusqu'à ce que le Mutex actuel
reçoive un signal. Pour obtenir la documentation
complète, consultez la rubrique relative à la classe de
base, WaitHandle..::.WaitOne()()().
• (Substitue WaitHandle..::.WaitOne()()().) (origine MSDN)

 ReleaseMutex()
• Libère une fois le Mutex.

81 D. Bourget

Classe AutoResetEvent
Définition :
 Cette classe permet d'avertir un ou plusieurs
threads en attente qu'un événement s'est produit.
 En fait il faut considérer que cette classe ne laisse
passer qu'un seul thread à la fois
 Cette classe est de même catégorie que la classe
Mutex et la clause lock

82 D. Bourget

Page 41
 Classe AutoResetEvent
Les méthodes (origine MSDN)
 Set
• Définit l'état de l'événement comme étant signalé, ce
qui permet à un ou plusieurs threads en attente de
continuer.
 Reset
• Définit l'état de l'événement comme étant non signalé,
entraînant le blocage des threads.
 WaitOne
• Surchargé. En cas de substitution dans une classe
dérivée, bloque le thread en cours jusqu'à ce que le
WaitHandle en cours reçoive un signal.

83 D. Bourget

Page 42