Gestion des processus dans les syst`emes r´epartis
Gestion des processus dans les syst`emes r´epartis
K. Barbaria
Facult´e des Sciences de Bizerte
Novembre 2009
Syst`emes Distribu´es (FSB 2009)
K. Barbaria
1/17
Gestion des processus dans les syst`emes r´epartis
1
Introduction
2 Support des threads en Java
3 Multithreading dans les applications client/serveur
Syst`emes Distribu´es (FSB 2009)
K. Barbaria
2/17
Gestion des processus dans les syst`emes r´epartis
Notion de processus
Processus
Un processus est un programme en train de s’ex´ecuter. Le
processus est une activit´e qui se voit attribuer des ressources et
dont l’´etat ´evolue au cours du temps.
Le processus est une unit´e abstraite qui repr´esente l’ex´ecution
du programme. Elle est ind´ependante des ressources
physiques (processeur, m´emoire, etc.).
Cons´equences : un processeur peut ex´ecuter plusieurs
processus en mˆeme temps (pseudo parall´elisme). Deux
processus peuvent ˆetre ex´ecut´es en parall`ele sur une machine
multiprocesseur.
La notion de processus permet de repr´esenter des activit´es et
de raisonner sur leurs interactions.
Exemple de processus : ex´ecution d’un programme, copie de
fichier, envoi d’un paquet sur le r´eseau.
Syst`emes Distribu´es (FSB 2009)
K. Barbaria
3/17
Gestion des processus dans les syst`emes r´epartis
Relations entre les processus
Les processus sont rarement ind´ependants, ils sont souvent en
concurrence et peuvent ˆetre amen´es `a collaborer.
Comp´etition (sur les ressources)
Exemple de processeur, espace m´emoire partag´e, imprimante,
etc.
Un processus doit attendre la lib´eration de la ressource !
Que se passe t-il si plusieurs processus sont en attente?!
Coop´eration (pour atteindre un objectif commun)
Un premier processus cr´ee une image, un second l’affiche `a
l’´ecran, un troisi`eme l’imprime, etc.
Peut n´ecessiter une synchronisation : un processus doit
attendre qu’un ´ev`enement ait lieu au niveau d’un autre
processus.
Syst`emes Distribu´es (FSB 2009)
K. Barbaria
4/17
Gestion des processus dans les syst`emes r´epartis
Communications entre les processus
IPC : Inter-Process Communication : aspect important de la
programmation de syst`emes.
Moyens de communications entre les processus :
Signaux : un processus se bloque dans l’attente de l’arriv´ee
d’un signal. `A l’arriv´ee du signal le processus ex´ecute une ou
plusieurs fonctions.
M´emoire partag´ee si l’OS le permet (exemple segments de
m´emoire partag´ee d’UNIX)
Communication par fichiers en utilisant le syst`eme de fichiers
local ou un syst`eme de fichier distribu´e (exemple : NFS)
Sockets (si les processus communiquent `a travers un r´eseau
mais il est possible d’utiliser les sockets en local)
Middleware (RPC, File de messages (Message Queues), Objets
distribu´es, etc).
La communication inter processus est coˆuteuse (changement
de contexte) mais s´ecuris´ee (pas de corruption)
Syst`emes Distribu´es (FSB 2009)
K. Barbaria
5/17
Gestion des processus dans les syst`emes r´epartis
Thread (fil d’ex´ecution)
Un thread est une partie des instructions du processus en cours
d’ex´ecution. Un thread est souvent consid´er´e comme un processus
l´eger.
Un processus peut contenir un ou plusieurs threads
(multithreading) s’ex´ecutant en parall`ele (pseudo parall´elisme
ou parall´elisme).
Comme les processus, chaque thread maintient un flot de
contrˆole qui lui est propre.
A la diff´erence des processus, les threads partagent les mˆemes
ressources (mˆeme espace d’adressage).
Le multithreading permet d’am´eliorer la performance globale
et la transparence de plusieurs applications. Par exemple, un
serveur en mode multithreading continue `a recevoir les
connexions mˆeme s’il est encore en train de traiter d’autres
requˆetes.
Syst`emes Distribu´es (FSB 2009)
K. Barbaria
6/17
Gestion des processus dans les syst`emes r´epartis
Thread et processus
Processus
Peut supporter plusieurs
Publicité
threads
Unit´e d’allocation
(changement
Unit´e
Communication Coˆuteuse
Fiabilit´e
de contexte)
Garantie par l’OS
Performances
limit´ees par changement
de contexte
Thread
Attach´e `a un seul proces-
sus
Unit´e d’ex´ecution
Faible coˆut
Risque de corruption des
donn´ees
Bonnes
Syst`emes Distribu´es (FSB 2009)
K. Barbaria
7/17
Gestion des processus dans les syst`emes r´epartis
Cr´eation de Threads en Java
Java fournit deux moyens pour cr´eer les threads : h´eriter de
Thread ou impl´ementer Runnable.
java.lang.Thread
Constructeur : public Thread() cr´ee un nouvel objet ”Thread”
join() Attend que le thread termine son ex´ecution.
sleep(long millis) fait en sorte que le thread cesse son
ex´ecution pendant un nombre de millisecondes donn´e.
start() demande au thread de commencer son ex´ecution. La
JVM appelle la m´ethode run () du thread.
yield() le thread passe la main aux autres threads en attente.
Interrupt() interrompt l’ex´ecution du thread.
Syst`emes Distribu´es (FSB 2009)
K. Barbaria
8/17
Gestion des processus dans les syst`emes r´epartis
Cr´eation 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´esultat :
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`emes Distribu´es (FSB 2009)
K. Barbaria
9/17
Gestion des processus dans les syst`emes r´epartis
Cr´eation de Threads en Java
java.lang.Runnable
L’interface Runnable doit ˆetre impl´ement´ee par toute classe qui
veut disposer d’un thread (objet actif). Cette interface permet `a
une classe d’ˆetre active sans h´eriter de Thread. Une classe
impl´ementant Runnable peut ˆetre lanc´ee en cr´eant un nouveau
Thread avec en param`etre 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 ) ; }
Publicité
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`emes Distribu´es (FSB 2009)
K. Barbaria
10/17
Gestion des processus dans les syst`emes r´epartis
Interruption des Threads Java
Interruption d’un Thread
M´ethodes de la classe Thread pour la gestion des interruptions:
void interrupt() permet d’interrompre un thread
boolean isInterrupted() true si le thread a ´et´e 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
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`emes Distribu´es (FSB 2009)
K. Barbaria
11/17
Gestion des processus dans les syst`emes r´epartis
Concurrence
Les threads partagent les mˆemes ressources (variables du
processus, espaces m´emoires, etc). La coh´erence peut ˆetre
facilement perdue.
Attention : une op´eration qui semble ˆetre atomique peut ˆetre
d´ecompos´ee en plusieurs sous op´erations par le syst`eme 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
Publicité
8
9
10
11
12
Syst`emes Distribu´es (FSB 2009)
K. Barbaria
12/17
Gestion des processus dans les syst`emes r´epartis
Protection contre les acc`es concurrents
Utiliser le mot clef synchronized pour prot´eger les sections
critiques (code qui ne doit pas ˆetre ex´ecut´e par plus d’un
thread)
Assure une ex´ecution 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`emes Distribu´es (FSB 2009)
K. Barbaria
13/17
Gestion des processus dans les syst`emes r´epartis
Protection contre les acc`es concurrents (2)
L’appel d’une m´ethode synchronized n´ecessite l’otention d’un
verrou. Chaque objet a un verrou associ´e.
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´e lorsque le thread sort du bout de code
prot´eg´ee par synnchronized
Attention aux m´ethodes statiques, synchroniser une m´ethode
statique peut bloquer l’acces a toute la classe!
Remarques :
Java permet de prot´eger des blocks de code.
Pour plus d’information, voir java.util.concurrent.locks
Syst`emes Distribu´es (FSB 2009)
K. Barbaria
14/17
Gestion des processus dans les syst`emes r´epartis
Multithreading dans les applications client/serveur
Il est possible d’avoir du multithreading cot´e client comme cot´e
serveur :
Serveur multithread´e : un thread pour accepter des
connexions, les autres pour r´epondre au clients.
Client multithread´e : pour contacter plusieurs serveurs
quasi-simultan´ement.
Syst`emes Distribu´es (FSB 2009)
K. Barbaria
15/17
Gestion des processus dans les syst`emes r´epartis
Un serveur Multithread´e
1
2
3
4
5
6
7
8
9
Publicité
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`emes Distribu´es (FSB 2009)
K. Barbaria
16/17
Gestion des processus dans les syst`emes r´epartis
Un serveur Multithread´e (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`emes Distribu´es (FSB 2009)
K. Barbaria
17/17