Synchronisation en Java

Transcription

1 Université de Provence MASTER INFORMATIQUE Programmation Parallèle et Distribuée Synchronisation en Java Synchronisation en Java 1. Quelle est la différence entre visibilité et atomicité? Solution : Visibilité : cohérence au niveau des threads, c est-à-dire que chaque thread voit la même valeur pour la variable à un moment donné. Atomicité : chaque opération sur l objet est atomique, c est-à-dire quelle est en exclusion mutuelle avec les autres opérations. 2. Qu est-ce qu une structure de données thread-safe? Comment se fait-il qu il existe des structures de données non thread-safe? Solution : Structure de données pouvant être utiliser correctement et sans risque lors d une exécution simultanée par plusieurs processus légers. Il existe des structure de données non thread-safe car la gestion de la synchronisation est couteuse et inutile dans le cas où la structure de donnée n est pas partagée. 3. Quel est l intérêt d utiliser des files d attente? Donner les principales différences entre LinkedList, LinkedBlockingQueue et ConcurrentLinkedQueue. Solution : les files d attente sont utiles pour un modèle producteur-consommateur dans lequel un ou plusieurs thread produisent des ressources qui sont utilisées par d autres threads. LinkedList n est pas thread-safe, il faut la synchroniser (par exemple par encapsulation) pour pouvoir l utiliser dans plusieurs threads. LinkedBlockingQueue : file thread-safe. Lorsque l on défile et que la file est vide, le thread attend que la file se remplisse. De même lorsque la file est pleine (capacité maximale atteinte), le thread attend qu elle se vide. 2 Problèmes Classiques 1. Ecrire le problème des Producteurs et Consommateurs en Java. avec ArrayBlockingQueue avec LinkedBlockingQueue avec Semaphore (Indication : on pourra définir une classe SemBlockingQueue implémentant l interface BlockingQueue.) Solution : Pseudo-code de producteur-consommateur c r é e r un document D v e r r o u i l l e r F : a j o u t e r D à l a f i n de l a f i l e F envoyer un s i g n a l par F au processus consommateur d é v e r r o u i l l e r F 1

2 v e r r o u i l l e r F : t a n t qu i l y a des consommateurs : attendre s i g n a l de F pour chaque éléments D de F : t r a i t e r D f i n pour e f f a c e r tous l e s éléments de l a f i l e F f i n tant que d é v e r r o u i l l e r F Constructeur : ArrayBlockingQueue(int capacity, boolean fair) Si fair est égal à true les threads en attente d éléments sont réveillés selon la règle FIFO. Ajout/production : boolean offer(e o) : met l élément s il a de l espace, ne fait rien sinon. void put(e o) : attend pour de l espace. boolean offer(e o, long timeout, TimeUnit unit) : attend avec un timeout pour de l espace. Retrait/ consommation : E poll() : défile la tête de file. Retourne null si la file est vide E take() : défile la tête de file. Attends un élément si la file est vide. E poll(long timeout, TimeUnit unit) : défile la tête de file. Attends timeout pour un élément si la file est vide. Constructeur : Summary LinkedBlockingQueue() Ajout/production : boolean offer(e o) : met l élément s il a de l espace, ne fait rien sinon. void put(e o) : attend pour de l espace. boolean offer(e o, long timeout, TimeUnit unit) : attend avec un timeout pour de l espace. Retrait/ consommation : E poll() : défile la tête de file. Retourne null si la file est vide E take() : défile la tête de file. Attends un élément si la file est vide. E poll(long timeout, TimeUnit unit) : défile la tête de file. Attends timeout pour un élément si la file est vide. Constructeur : Semaphore (int permits, boolean fair) Si fair est égal à true les threads en attente de permis sont réveillés selon la règle FIFO. Interface BlockingQueue< E > : boolean add(e o) : Adds the specified element to this queue if it is possible to do so immediately, returning true upon success, else throwing an IllegalStateException. int drainto(collection<? super E> c) : Removes all available elements from this queue and adds them into the given collection. int drainto(collection<? super E> c, int maxelements) : Removes at most the given number of available elements from this queue and adds them into the given collection. boolean offer(e o) : Inserts the specified element into this queue, if possible. boolean offer(e o, long timeout, TimeUnit unit) : Inserts the specified element into this queue, waiting if necessary up to the specified wait time for space to become available. E poll(long timeout, TimeUnit unit) : Retrieves and removes the head of this queue, waiting if necessary up to the specified wait time if no elements are present on this queue. void put(e o) : Adds the specified element to this queue, waiting if necessary for space to become available. int remainingcapacity() : Returns the number of elements that this queue can ideally (in the absence of memory or resource constraints) accept without blocking, or Integer.MAX VALUE if there is no intrinsic limit. 2

3 E take() : Retrieves and removes the head of this queue, waiting if no elements are present on this queue. public c l a s s SemBlockingQueue<E> implements BlockingQueue<E> { private LinkedList l ; private Semaphore f u l l, empty, mutex ; public SemBlockingQueue ( I n t capacity, boolean f a i r ) { l =new LinkedList ( ) ; f u l l =new Semaphore ( 0, f a i r ) ; empty=new Semaphore ( capacity, f a i r ) ; mutex=new Semaphore ( 1, f a i r ) ; public boolean add ( E o ) throws InterruptedException { empty. acquire ( ) ; mutex. acquire ( ) ; l. add ( E o ) ; mutex. r e l e a s e ( ) ; f u l l. r e l e a s e ( ) ; public E take ( ) throws InterruptedException { f u l l. acquire ( ) ; mutex. acquire ( ) ; l. add ( E o ) ; mutex. r e l e a s e ( ) ; empty. r e l e a s e ( ) ; 3 Problème du coiffeur Un coiffeur dispose d une chaise de coiffure et d une salle d attente avec un certain nombre de places. Lorsqu un coiffeur a fini de couper les cheveux d un client, il le fait sortir et va à la salle d attente afin de vérifier s il n y a pas d autres clients. S il trouve un nouveau client, il l amène à la chaise et lui coupe les cheveux. S il n y pas de nouveau client, il va dormir sur la chaise. Un nouveau client qui arrive, vérifie si le coiffeur dort. S il dort, il le réveille et se fait couper les cheveux. Si le coiffeur est déjà occupé avec un autre client, il va à la salle d attente. S il y a assez de place, il attends jusqu à que le coiffeur viennent le chercher, sinon il s en va. On considère que chaque action (couper les cheveux, se déplacer, vérifier les états des autres personnes) prends un certain temps qui dépends de la personne. 1. Est-ce-que le comportement décrit garanti que le coiffeur ne dorme pas si un client est en train d attendre? 2. Comment résoudre les éventuels problèmes qui peuvent se produire? Solution : + Semaphore Customers = 0 + Semaphore Barber = 0 + Semaphore a c c e s s S e a t s ( mutex ) = 1 3

4 + i n t NumberOfFreeSeats = N // t o t a l number of s e a t s The Barber ( Thread/Process ) : \ begin { l s t l i s t i n g while ( true ) { //runs in an i n f i n i t e loop P ( Customers ) // t r i e s to acquire a customer i f none i s a v a i l a b l e he goes to sleep P ( a c c e s s S e a t s ) //at t h i s time he has been awakened want to modify the number of a v NumberOfFreeSeats++ //one c h a i r gets f r e e V( Barber ) //the barber i s ready to cut V( a c c e s s S e a t s ) //we don t need the lock on the c h a i r s anymore //here the barber i s c u t t i n g h a i r The Customer (Thread/Process) : while ( true ) { //runs in an i n f i n i t e loop P ( a c c e s s S e a t s ) // t r i e s to get a c c e s s to the c h a i r s i f ( NumberOfFreeSeats > 0 ) { // i f there are any f r e e s e a t s NumberOfFreeSeats // s i t t i n g down on a c h a i r V( Customers ) // n o t i f y the barber, who s waiting t h a t there i s a customer V( a c c e s s S e a t s ) //don t need to lock the c h a i r s anymore P ( Barber ) //now i t s t h i s customer s turn, but wait i f the barber i s busy //here the customer i s having h i s h a i r cut e l s e { //there are no f r e e s e a t s //tough luck V( a c c e s s S e a t s ) //but don t f o r g e t to r e l e a s e the lock on the s e a t s //customer leaves without a h a i r c u t 4 Les philosophes Il y a cinq philosophes autour d une table : Descartes, Voltaire, Socrate, Platon et Confucius. Sur la table, il y a cinq assiettes de spaghetti mais il n y a que cinq fourchettes (une entre deux assiettes). Malheureusement il leur faut les deux fourchettes (celle à droite et celle à gauche) pour manger. Un philosophe peut être dans un des trois états suivant : penser pendant un temps indéterminé ; être affamé (pendant un temps déterminé et fini sinon il y a famine) ; manger pendant un temps déterminé et fini. Quand un philosophe est affamé, il a le droit de prendre une de ses deux fourchettes si elle disponible (elle n a pas été prise par son voisin). S il obtient ses deux fourchettes, il mange et libère les fourchettes pour ses voisins. S il n arrive pas à obtenir les deux fourchettes, il reste affamé jusqu à qu il les obtiennent. 1. Modélisez le problème et le comportement d un philosophe, afin d éviter les famines et les étreintes fatales. 2. Que se passe-t-il si un philosophe meurt (crash de processus) alors qu il avait une fourchette? 4

5 5