Gestion des processus dans les systèmes répartis
Gestion des processus dans les systèmes répartis
K. Barbaria
Faculté des Sciences de Bizerte
Novembre 2009
Systèmes Distribués (FSB 2009)
K. Barbaria
1/17
Gestion des processus dans les systèmes répartis
1
Introduction
2 Support des threads en Java
3 Multithreading dans les applications client/serveur
Systèmes Distribués (FSB 2009)
K. Barbaria
2/17
Gestion des processus dans les systèmes répartis
Notion de processus
Processus
Un processus est un programme en train de s’exécuter. Le
processus est une activité qui se voit attribuer des ressources et
dont l’état évolue au cours du temps.
Le processus est une unité abstraite qui représente l’exécution
du programme. Elle est indépendante des ressources
physiques (processeur, mémoire, etc.).
Conséquences : un processeur peut exécuter plusieurs
processus en même temps (pseudo parallélisme). Deux
processus peuvent être exécutés en parallèle sur une machine
multiprocesseur.
La notion de processus permet de représenter des activités et
de raisonner sur leurs interactions.
Exemple de processus : exécution d’un programme, copie de
fichier, envoi d’un paquet sur le réseau.
Systèmes Distribués (FSB 2009)
K. Barbaria
3/17
Gestion des processus dans les systèmes répartis
Relations entre les processus
Les processus sont rarement indépendants, ils sont souvent en
concurrence et peuvent être amenés à collaborer.
Compétition (sur les ressources)
Exemple de processeur, espace mémoire partagé, imprimante,
etc.
Un processus doit attendre la libération de la ressource !
Que se passe t-il si plusieurs processus sont en attente?!
Coopération (pour atteindre un objectif commun)
Un premier processus crée une image, un second l’affiche à
l’écran, un troisième l’imprime, etc.
Peut nécessiter une synchronisation : un processus doit
attendre qu’un évènement ait lieu au niveau d’un autre
processus.
Systèmes Distribués (FSB 2009)
K. Barbaria
4/17
Gestion des processus dans les systèmes répartis
Communications entre les processus
IPC : Inter-Process Communication : aspect important de la
programmation de systèmes.
Moyens de communications entre les processus :
Signaux : un processus se bloque dans l’attente de l’arrivée
d’un signal. À l’arrivée du signal le processus exécute une ou
plusieurs fonctions.
Mémoire partagée si l’OS le permet (exemple segments de
mémoire partagée d’UNIX)
Communication par fichiers en utilisant le système de fichiers
local ou un système de fichier distribué (exemple : NFS)
Sockets (si les processus communiquent à travers un réseau
mais il est possible d’utiliser les sockets en local)
Middleware (RPC, File de messages (Message Queues), Objets
distribués, etc).
La communication inter processus est coûteuse (changement
de contexte) mais sécurisée (pas de corruption)
Systèmes Distribués (FSB 2009)
K. Barbaria
5/17
Gestion des processus dans les systèmes répartis
Thread (fil d’exécution)
Un thread est une partie des instructions du processus en cours
d’exécution. Un thread est souvent considéré comme un processus
léger.
Un processus peut contenir un ou plusieurs threads
(multithreading) s’exécutant en parallèle (pseudo parallélisme
ou parallélisme).
Comme les processus, chaque thread maintient un flot de
contrôle qui lui est propre.
A la différence des processus, les threads partagent les mêmes
ressources (même espace d’adressage).
Le multithreading permet d’améliorer la performance globale
et la transparence de plusieurs applications. Par exemple, un
serveur en mode multithreading continue à recevoir les
connexions même s’il est encore en train de traiter d’autres
requêtes.
Systèmes Distribués (FSB 2009)
K. Barbaria
6/17
Gestion des processus dans les systèmes répartis
Thread et processus
Processus
Peut supporter plusieurs
threads
Unité d’allocation
(changement
Unité
Communication Coûteuse
Fiabilité
de contexte)
Garantie par l’OS
Performances
limitées par changement
de contexte
Thread
Attaché à un seul proces-
sus
Unité d’exécution
Faible coût
Risque de corruption des
données
Bonnes
Systèmes Distribués (FSB 2009)
K. Barbaria
7/17
Gestion des processus dans les systèmes répartis
Création de Threads en Java
Publicité
Java fournit deux moyens pour créer les threads : hériter de
Thread ou implémenter Runnable.
java.lang.Thread
Constructeur : public Thread() crée un nouvel objet ”Thread”
join() Attend que le thread termine son exécution.
sleep(long millis) fait en sorte que le thread cesse son
exécution pendant un nombre de millisecondes donné.
start() demande au thread de commencer son exécution. La
JVM appelle la méthode run () du thread.
yield() le thread passe la main aux autres threads en attente.
Interrupt() interrompt l’exécution du thread.
Systèmes Distribués (FSB 2009)
K. Barbaria
8/17
Gestion des processus dans les systèmes répartis
Création de Threads en Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
c l a s s S i m p l e T h r e a d e x t e n d s Thread {
S t r i n g s t r i n g t o p r i n t ;
S i m p l e T h r e a d ( S t r i n g S ){ t h i s . s t r i n g t o p r i n t = new S t r i n g ( S ) ; } ;
p u b l i c v o i d r u n ( ) {
w h i l e ( t r u e ) {
System . o ut . p r i n t l n ( s t r i n g t o p r i n t ) ;
t h i s . y i e l d ( ) ; } }
p u b l i c
s t a t i c v o i d main ( S t r i n g a r g s [ ] ) {
S i m p l e T h r e a d T1 = new S i m p l e T h r e a d ( ” B o n j o u r ! ” ) ;
S i m p l e T h r e a d T2 = new S i m p l e T h r e a d ( ” B o n s o i r ! ” ) ;
T1 . s t a r t ( ) ; T2 . s t a r t ( ) ;
}
}
Résultat :
1 B o n j o u r !
2 B o n s o i r !
3 B o n j o u r !
4
. . .
Systèmes Distribués (FSB 2009)
K. Barbaria
9/17
Gestion des processus dans les systèmes répartis
Création de Threads en Java
java.lang.Runnable
L’interface Runnable doit être implémentée par toute classe qui
veut disposer d’un thread (objet actif). Cette interface permet à
une classe d’être active sans hériter de Thread. Une classe
implémentant Runnable peut être lancée en créant un nouveau
Thread avec en paramètre une instance de la classe.
1
2
3
4
5
6
7
8
9
c l a s s S i m p l e R u n n a b l e i m p l e m e n t s R unna bl e {
S t r i n g s t r i n g t o p r i n t ;
S i m p l e R u n n a b l e ( S t r i n g S ){ t h i s . s t r i n g t o p r i n t = new S t r i n g ( S ) ; } ;
p u b l i c v o i d r u n ( ) {
w h i l e ( t r u e ) System . o ut . p r i n t l n ( s t r i n g t o p r i n t ) ; }
p u b l i c
s t a t i c v o i d main ( S t r i n g a r g s [ ] ) {
Thread T = new Thread ( new S i m p l e R u n n a b l e ( ” B o n j o u r ” ) ) ;
T . s t a r t ( ) ;
10
11
}
}
Systèmes Distribués (FSB 2009)
K. Barbaria
10/17
Gestion des processus dans les systèmes répartis
Interruption des Threads Java
Interruption d’un Thread
Méthodes de la classe Thread pour la gestion des interruptions:
void interrupt() permet d’interrompre un thread
boolean isInterrupted() true si le thread a été interrompu
c l a s s N i c e T h r e a d e x t e n d s Thread {
p u b l i c v o i d r u n ( ) {
w h i l e (
! i s I n t e r r u p t e d ( )
) {
System . o ut . p r i n t l n ( ”From : ” + getName ( )
) ;
}
System . o ut . p r i n t l n ( ” C l e a n up o p e r a t i o n s ” ) ; }
}
p u b l i c
c l a s s
I n t e r r u p t T e s t {
p u b l i c
s t a t i c v o i d main ( S t r i n g a r g s [ ] )
t h r o ws
N i c e T h r e a d m i s s M a nner s = new N i c e T h r e a d ( ) ;
m i s s M a nner s . s e t P r i o r i t y ( 2 ) ;
m i s s M a nner s . s t a r t ( ) ;
Thread . c u r r e n t T h r e a d ( ) . s l e e p ( 2 ) ; // L e t o t h e r
m i s s M a nner s . i n t e r r u p t ( ) ; }
1
2
3
4
5
6
7
8
9
10
Publicité
11
12
13
14
15
}
I n t e r r u p t e d E x c e p t
t h r e a d r u n
Systèmes Distribués (FSB 2009)
K. Barbaria
11/17
Gestion des processus dans les systèmes répartis
Concurrence
Les threads partagent les mêmes ressources (variables du
processus, espaces mémoires, etc). La cohérence peut être
facilement perdue.
Attention : une opération qui semble être atomique peut être
décomposée en plusieurs sous opérations par le système ou la
JVM.
Qu’affiche le programme java suivant?
c l a s s C o n c u r r e n t e x t e n d s Thread {
p u b l i c
s t a t i c
s t a t i c v o i d i n c r e m e n t
i n t c =0;
( )
t h r o ws E x c e p t i o n {
i n t
f o r
l o c a l ;
( i n t
l o c a l =c ;
i =0; i <1000; i ++){
l o c a l ++;Thread . s l e e p ( 1 ) ; c= l o c a l ; }
}
p u b l i c v o i d r u n ( ) { t r y { i n c r e m e n t ( ) ; } c a t c h ( E x c e p t i o n e ){ } }
p u b l i c
s t a t i c v o i d main ( S t r i n g a r g s [ ] )
t h r o ws E x c e p t i o n {
C o n c u r r e n t T1 = new C o n c u r r e n t
C o n c u r r e n t T2 = new C o n c u r r e n t
T1 . s t a r t ( ) ; T2 . s t a r t ( ) ; T1 . j o i n ( ) ; T2 . j o i n ( ) ; } }
( ) ;
( ) ;
1
2
3
4
5
6
7
8
9
10
11
12
Systèmes Distribués (FSB 2009)
K. Barbaria
12/17
Gestion des processus dans les systèmes répartis
Protection contre les accès concurrents
Utiliser le mot clef synchronized pour protéger les sections
critiques (code qui ne doit pas être exécuté par plus d’un
thread)
Assure une exécution en exclusion mutuelle
c l a s s C o n c u r r e n t e x t e n d s Thread {
p u b l i c
s t a t i c
i n t c =0;
v o i d p r i n t ( ) { System . o ut . p r i n t l n ( c ) ; }
( )
s t a t i c s y n c h r o n i z e d v o i d i n c r e m e n t
t h r o ws E x c e p t i o n {
i n t
f o r
l o c a l ;
( i n t
l o c a l =c ;
i =0; i <1000; i ++){
l o c a l ++;Thread . s l e e p ( 1 ) ; c= l o c a l ; }
}
p u b l i c v o i d r u n ( ) { t r y { i n c r e m e n t ( ) ; } c a t c h ( E x c e p t i o n e ){ } }
p u b l i c
s t a t i c v o i d main ( S t r i n g a r g s [ ] )
t h r o ws E x c e p t i o n {
C o n c u r r e n t T1 = new C o n c u r r e n t
C o n c u r r e n t T2 = new C o n c u r r e n t
T1 . s t a r t ( ) ; T2 . s t a r t ( ) ; T1 . j o i n ( ) ; T2 . j o i n ( ) ;
T1 . p r i n t ( ) ; T2 . p r i n t ( ) ; }
( ) ;
( ) ;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Systèmes Distribués (FSB 2009)
K. Barbaria
13/17
Gestion des processus dans les systèmes répartis
Protection contre les accès concurrents (2)
L’appel d’une méthode synchronized nécessite l’otention d’un
verrou. Chaque objet a un verrou associé.
Si le thread appelant n’a pas obtenu le verrou (car le verrou
est chez un autre thread), le thread appelant est mis en
attente (du verrou)
le verrou est relaché lorsque le thread sort du bout de code
protégée par synnchronized
Attention aux méthodes statiques, synchroniser une méthode
statique peut bloquer l’acces a toute la classe!
Remarques :
Publicité
Java permet de protéger des blocks de code.
Pour plus d’information, voir java.util.concurrent.locks
Systèmes Distribués (FSB 2009)
K. Barbaria
14/17
Gestion des processus dans les systèmes répartis
Multithreading dans les applications client/serveur
Il est possible d’avoir du multithreading coté client comme coté
serveur :
Serveur multithreadé : un thread pour accepter des
connexions, les autres pour répondre au clients.
Client multithreadé : pour contacter plusieurs serveurs
quasi-simultanément.
Systèmes Distribués (FSB 2009)
K. Barbaria
15/17
Gestion des processus dans les systèmes répartis
Un serveur Multithreadé
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
i m p o r t
j a v a . i o . ∗ ; i m p o r t
j a v a . n e t . ∗ ; i m p o r t
j a v a . u t i l . ∗ ;
c l a s s M u l t i t h r e a d e d D a t e S e r v e r
i m p l e m e n t s R unna bl e {
c l a s s Worker
i m p l e m e n t s R unna bl e {
S o c k e t Soc ;
p u b l i c Worker
t h i s . Soc=S ;
}
( S o c k e t S ){
p u b l i c v o i d r u n ( ) {
t r y {
P r i n t W r i t e r o ut = new P r i n t W r i t e r
( Soc . g e t O u t p u t S t r e a m ( ) , t r u e ) ;
Thread . s l e e p ( 1 0 ∗ 1 0 0 0 ) ;
o ut . p r i n t l n ( new j a v a . u t i l . Date ( ) . t o S t r i n g ( ) ) ;
Soc . c l o s e ( ) ; // F e r m e t u r e de l a c o n n e x i o n
}
c a t c h ( E x c e p t i o n ex ) { System . o ut . p r i n t l n ( ex ) ; }
}
} // end Worker
Systèmes Distribués (FSB 2009)
K. Barbaria
16/17
Gestion des processus dans les systèmes répartis
Un serveur Multithreadé (suite)
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
p u b l i c v o i d r u n ( ) {
t r y {
S e r v e r S o c k e t w el co m eS o ck et = new S e r v e r S o c k e t ( 6 7 8 9 ) ;
w h i l e ( t r u e ){
S o c k e t
Thread T = new Thread ( new Worker
T . s t a r t ( ) ;
}
c l i e n t = w el co m eS o ck et . a c c e p t ( ) ;
( c l i e n t ) ) ;
}
c a t c h ( E x c e p t i o n ex ){ System . o ut . p r i n t l n ( ex ) ; }
}
p u b l i c
s t a t i c v o i d main ( S t r i n g a r g v
[ ] )
t h r o ws E x c e p t i o n {
Thread t = new Thread ( new M u l t i t h r e a d e d D a t e S e r v e r
t . s t a r t ( ) ;
Thread . s l e e p ( 5 9 ∗ 1 0 0 0 ) ;
System . o ut . p r i n t l n
( ” 59 s e c o n d e s
e c o u l e e s . .
s e s o n t
l e
( ) ) ;
s e r v e u r va s ’ a r r e t e r ” ) ;
t . s t o p ( ) ;
}
}
Systèmes Distribués (FSB 2009)
K. Barbaria
17/17