La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

La programmation concurrente en Java Les Threads.

Présentations similaires


Présentation au sujet: "La programmation concurrente en Java Les Threads."— Transcription de la présentation:

1 La programmation concurrente en Java Les Threads

2 Le problème (1) Java permet le multitasking Il le fait via les threads (processus légers) Divers threads partagent le même espace mémoire mais pas les registres Quand la JVM donne la main à un thread, il load ses registres et stocke ceux du thread précédent. Exemple : thread1thread2 compte1.virer(100, compte2);compte2.virer(100, compte1);

3 Le problème (2) En code exécutable, cela donne pour le premier thread : R1 = compte1.solde; R1 -= 100; compte1.solde = R1; R1 = compte2.solde; R1 += 100; compte2.solde = R1

4 Le problème (3) Lexécution des 2 threads pourra donner : thread 1thread2 R1 = compte1.solde; R1 -= 100; compte1.solde = R1; R1 = compte2.solde R1 -= 100; R1 = compte2.solde; R1 += 100; compte2.solde = R1 compte2.solde = R1; R1 = compte1.solde; R1 += 100; compte1.solde = R1

5 Le problème (4) Après lexécution le compte1 retrouve le même solde que précédemment. Par contre le compte2 voit son solde diminué de 100 ! Il aurait fallu que le retrait et le dépôt soient des opérations atomiques.

6 Créer un Thread (1) 1 ère méthode : Définition : public class MonThread extends Thread { public void run() { ….. } Exécution : Thread thread = new MonThread(); thread.start(); Attention : ne pas appeler run(); start() exécute run() dans un autre thread (unité dexécution)

7 Créer un Thread (2) 2 ème méthode : Définition : public class MonRunnable implements Runnable { public void run() { ….. } Exécution : Thread thread = new Thread(new MonRunnable()); thread.start(); Attention : ne pas appeler run() Thread est le contrôleur et Runnable la tâche

8 Cycle de vie Le Thread existe depuis quon a appelé son constructeur Avant dappeler start(), on pourra procéder à des initialisation Après quil ait terminé lexécution de run(), le Thread continue à exister. On pourra en profiter pour récupérer des résultats

9 Méthodes static Thread currentThread(); static void sleep(long millis); static void yield(); // passe la main static boolean interrupted(); // clear status void run(); void start(); void interrupt(); boolean isInterrupted(); // keep status void join(); // thread.join() attend la fin de thread InterruptedException // clear status

10 Arrêter un Thread (1) un Thread sarrête quand il termine lexécution de run(); Si la décision de terminer est extérieure : 2 manières –en testant une condition –par interruption

11 Arrêter un Thread (2) En testant une condition : public class MonThread extends Thread { private volatile boolean fini = false; public void run() { while (! fini) { ….. } public void terminer() { fini = true; }

12 Arrêter un Thread (3) En interrompant le Thread : public class MonThread extends Thread { public void run() { while (! isInterrupted()) { ….. }

13 Locking Chaque objet possède un lock (un moniteur) Si une méthode ou un bloc est synchronized, il faudra acquérir le lock de lobjet avant de lexécuter Si le lock est libre, on y va Si le lock est acquis par un autre thread, on attend quil se libère Si dans une méthode ou un block synchronized, on appelle une autre méthode synchronized, il ne faudra pas acquérir le lock une deuxième fois

14 Méthode synchronized public synchronized int getCompteur() { return compteur; } public synchronized increment() { compteur++; }

15 Bloc synchronized public void incrementAfterOneSecond() { try { Thread.sleep(1000); // pas dans le synchronized // car sleep ne perd pas le lock } catch (InterruptedException ie) { } synchronized (this) { compteur++; }

16 Méthode ou bloc static synchronized (1) Une méthode static synchronized ne peut pas, bien évidemment, obtenir un lock sur this. Elle obtient un lock sur un autre objet : celui représentant la classe dans Class. public class CompteTout { private static int cpt = 0; public static synchronized void incr() { cpt++; } ….. } acquiert une lock sur CompteTout.class

17 Méthode ou bloc static synchronized (2) Une méthode non static accédant à cpt devra acquérir le lock sur le même objet donc Faux : public synchronized int getCpt() { return cpt; } Correct : public int getCpt() { synchronized(CompteTout.class) { return cpt; }

18 volatile Un champ peut être déclaré volatile dans ce cas au moment dun changement de thread, la JVM stocke un registre contenant cette variable dans la variable elle-même le champ doit être sur 32 bits maximum pas valable pour une adresse (tableau, objet) : ce serait ladresse qui serait mis à jour pas ce quelle désigne évite de mettre synchronized des méthodes qui ne font que des lectures ou des affectations simples (=) du champ pas de ++ ou de += …..

19 Deadlock (1) Un deadlock arrive si deux ou plusieurs threads tentent dacquérir un lock détenu par un autre qui ne pourra pas le libérer pour lune ou lautre raison exemple : MonDeadlock

20 Deadlock (2) public class MonDeadlock extends Thread { private boolean fini = false; public synchronized void run() { while (!fini) { System.out.println("je run"); try { Thread.sleep(1000); } catch (InterruptedException e) { } public synchronized void terminer() { fini = true; }

21 Deadlock (3) Solution : public class MonThread extends Thread { private boolean fini = false; public void run() { while (!getFini()) { System.out.println("je run"); try { Thread.sleep(1000); } catch (InterruptedException e) { } private synchronized boolean getFini() { return fini; } public synchronized void terminer() { fini = true; }

22 Comment synchroniser (1) Repérer dans vos classes les champs qui peuvent être modifiés et sont accédés par plusieurs threads. mettre synchronized (sur this) les parties des méthodes qui accèdent à ces champs si plusieurs champs dun même objet sont accédés dans la même méthode se demander si lensemble de ces accès doit être atomique si cest le cas synchroniser (sur this) cet ensemble (synchroniser éventuellement la méthode)

23 Comment synchroniser (2) si des méthodes dobjets différents (de classes différentes) sont appelées dans une méthode, se demander si lensemble de ces accès doit être atomique. si non, ne pas synchroniser les appels des méthodes sur les objets extérieurs : public class Portefeuille { public versement(double montant, Compte c) { synchronized (this) { this.contenu -= montant; } c.dépot(montant) // où dépôt est une méthode synchronized }

24 Comment synchroniser (3) si oui, ordonner les objets (acquérir les locks toujours dans le même ordre) public void transférer (Portefeuille p, Compte c) { synchronized(p) { synchronized(c) { c.dépot(p.getContenu()); } une autre méthode qui devrait locker les deux même objets le ferait dans le même ordre Ici cest simple il suffit dordonner les classes

25 Comment synchroniser (4) si des champs dobjets différents (de la même classe) sont accédés dans la même méthode, se demander si lensemble de ces accès doit être atomique. si non, synchroniser séparément les accès des champs des divers objets public virement(double montant, Compte c) { synchronized (this) { this.solde -= montant; } synchronized(c) { c.solde += montant; } }

26 Comment synchroniser (5) si oui, ordonner les objets sur lesquels on synchronise : par exemple si on a public static int cpt = 0; public int monCpt = 0; public synchronized static incr() { cpt++; } public synchronized static decr() { cpt--; }

27 Comment synchroniser (6) si on veut que lensemble des deux incrémentations soit atomique, on fera : public synchronized void incrémenter() { synchronized (CompteTout.class) { incr(); monCpt++; } on a acquis dabord le lock sur this puis sur CompteTout.class une autre méthode (décrémenter, par exemple) devrait les acquérir dans le même ordre

28 Comment synchroniser (7) Le cas le plus difficile est quand on doit synchroniser deux objets de la même classe Il faut alors ordonner ces objets parfois un champs de lobjet le permet sinon on utilisera System.identityHashCode()

29 Comment synchroniser (8) Si on doit locker les deux comptes lors dun virement on pourra utiliser le numéro de compte: public virement(double montant, Compte c) { if (this.numCompte < c.numCompte) synchronized (this) { synchronized(c) { this.solde -= montant; c.solde += montant; } } else synchronized (c) { synchronized(this) { this.solde -= montant; c.solde += montant; } } }

30 Attendre une ressource La méthode wait() héritée dObject Doit être appelée sur un objet dont on a acquis le lock Donc dans une méthode synchronized ou un bloc synchronized sur cet objet le thread courant est placée sur une file dattente liée à cet objet il libère le lock sur lobjet durant le wait();

31 Prévenir de la disponibilité dune ressource Les méthodes notify() et notifyAll() héritées dObject Doit être appelée sur un objet dont on a acquis le lock Donc dans une méthode synchronized ou un bloc synchronized sur cet objet notify() libère un thread en attente sur la file liée à lobjet notifyAll() les libère tous mais un seul passera

32 Bon usage de wait/notify notify réveille un thread, mais pas nécessairement le bon Il vaut mieux dans la plupart des cas utiliser notifyAll Ne pas faire if (! condition) wait(); –si on est réveillé alors que condition nest pas vraie on cesse dattendre Faire while (! condition) wait();

33 Double wait() Ne pas faire : wait(); Car deux notify() pourraient se produire avant de sortir du premier wait(); le 2 nd notify est alors perdu Faire while (nombreDeNotify < 2) wait();

34 Être sur de notifier Pour être certain que le notify soit fait et qu'on libère bien ceux qui attendent même en cas de problème, toujours faire le notify dans un bloc finally try { … } finally { notifyAll(); // ou notify(); selon les cas }

35 Double-checked Locking : NON Comment synchroniser une lazy initialization exemple (un singleton) : public static Singleton getInstance() { if (instance == null) instance = new Singleton(); return instance; }

36 Double-checked Locking : NON le double-checked locking ne fonctionne pas : public static Singleton getInstance() { if (instance == null) synchronized(Singleton.class) { if (instance == null) instance = new Singleton(); } return instance; } un autre thread risque de ne pus trouver instance à null avant la fin de linitialisation !

37 Double-checked Locking : NON Solution : synchroniser la méthode public static synchronized Singleton getInstance() { if (instance == null) instance = new Singleton(); return instance; }

38 wait(), sleep() et synchronisation On essaiera de libérer tous les moniteurs (et autres locks) avant de faire un wait() (sauf celui de lobjet sur lequel on wait();). Il y a un énorme risque de deadlock à ne pas le faire. lusage de variable locale est parfois utile, celles-ci ne devant pas être synchronisées Dans le même ordre didée, on libérera tous les moniteurs, locks, … avant de faire un sleep();

39 Timer et TimerTask (1) Dans un contexte non graphique nutilisez pas javax.swing.Timer !!! Ici aussi, Timer est le contrôleur et TimerTask, la tâche class Tâche extends TimerTask { public void run() { System.out.println("action !"); }

40 Timer et TimerTask (2) Timer timer = new Timer(); timer.schedule(new Tâche(), 5000); // la tâche sexécutera dans 5 secondes timer.schedule(new Tâche(), 5000, 1000); // la tâche sexécutera dans 5 secondes puis toutes les // secondes (en temps relatif, décalage possible) timer.scheduleAtFixedRate(new Tâche(), 5000, 1000); // la tâche sexécutera dans 5 secondes puis toutes les // secondes (en temps absolu, non exécution possible) timer.cancel() // plus dexécution après ça

41 Concurrence en Java 5.0 Le package java.util.concurrent fournit des classes utilitaires : –Semaphore –CyclicBarrier –CountDownLatch –Exchanger –diverses implémentation de linterface BlockingQueue –linterface Callable –FutureTask –Executor, ExecuterService et ThreadPoolExecutor

42 BlockingQueue boolean add(E e) -> IllegalStateException si plein E remove() -> NoSuchElementException si vide boolean offer(E e) -> false si plein E poll() -> null si vide void put(E e) -> attend si plein E take() -> attend si vide

43 BlockingQueue : producteur- consommateur (1) public class Producteur implements Runnable { private BlockingQueue queue; private Random random = new Random(); public Producteur(BlockingQueue queue) { this.queue = queue; } public void run() { while (true) { try { queue.put(random.nextInt(1000)); } catch (InterruptedException e) { }

44 BlockingQueue : producteur- consommateur (2) public class Consommateur implements Runnable { private BlockingQueue queue; public Consommateur(BlockingQueue queue) { this.queue = queue; } public void run() { while (true) { try { System.out.println(queue.take()); } catch (InterruptedException e) { }

45 BlockingQueue : producteur- consommateur (3) import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; public class Main { public static void main(String[] args) { BlockingQueue queue = new ArrayBlockingQueue (5); new Thread(new Producteur(queue)).start(); new Thread(new Consommateur(queue)).start(); }

46 Semaphore : théorie Semaphore( int nombreDePermis); // 1 == binaire Semaphore (int nombreDePermis, boolean FIFO); void acquire(); // aussi avec un nbPermis void acquireUninterruptibly(); // aussi avec un nbPermis void release(); // aussi avec un nbPermis boolean tryAcquire(); // aussi avec un nbPermis boolean tryAcquire(long timeout, TimeUnit unités); // aussi avec un nbPermis (en 1 er paramètre)

47 Semaphore (1) public class Noeud implements Cloneable { private int valeur; private Noeud suivant; private Semaphore semaphore = new Semaphore(1); public Noeud(int valeur) { this(valeur, null); } public Noeud(int valeur, Noeud suivant) { this.valeur = valeur; this.suivant = suivant; } public Noeud getSuivant() { return suivant; }

48 Semaphore (2) public void setSuivant(Noeud suivant) { this.suivant = suivant; } public int getValeur() { return valeur; } public void setValeur(int valeur) { this.valeur = valeur; } public Semaphore getSemaphore() { return semaphore; }

49 Semaphore (3) public class Liste { private Noeud tête; public boolean estVide() { return tête == null; } public String toString() { try { String rés = "[ "; for (Noeud n = tête; n != null; n = n.getSuivant()) { n.getSemaphore().acquire(); rés += n.getValeur() + " "; n.getSemaphore().release(); } rés += "]";return rés; } catch (InterruptedException e) { return null; } }

50 Semaphore (4) public boolean ajouterNoeud(int valeur) { Noeud n = new Noeud(valeur); if (estVide()) { tête = n; return true; } try { Noeud prec = null; Noeud noeud = tête; for (; noeud != null; noeud = noeud.getSuivant()) { noeud.getSemaphore().acquire(); if (n.getValeur() == noeud.getValeur()) { if (prec != null) prec.getSemaphore().release(); noeud.getSemaphore().release(); return false; }

51 Semaphore (5) if (n.getValeur() < noeud.getValeur()) { if (prec == null) { n.setSuivant(noeud); tête = n; noeud.getSemaphore().release(); return true; } break; } if (prec != null) prec.getSemaphore().release(); prec = noeud; } n.setSuivant(noeud); prec.setSuivant(n); prec.getSemaphore().release(); if (noeud != null) noeud.getSemaphore().release(); return true; } catch (InterruptedException e) { return false;} }

52 Semaphore (6) public boolean supprimerNoeud(int valeur) { if (estVide()) return false; try { Noeud prec = null; Noeud noeud = tête; for (; noeud != null; noeud = noeud.getSuivant()) { noeud.getSemaphore().acquire(); if (valeur == noeud.getValeur()) { if (prec == null) { tête = tête.getSuivant(); noeud.getSemaphore().release(); return true; }

53 Semaphore (7) prec.setSuivant(noeud.getSuivant()); noeud.setSuivant(null); prec.getSemaphore().release(); noeud.getSemaphore().release(); return true; } // fin du if == if (prec != null) prec.getSemaphore().release(); prec = noeud; } prec.getSemaphore().release(); if (noeud != null) noeud.getSemaphore().release(); } catch (InterruptedException e) { } return false; }

54 Semaphore (8) public class Main { public static void main(String[] args) { final Random random = new Random(); final Liste liste = new Liste(); new Thread() { public void run() { int cpt = 0; while (true) { liste.ajouterNoeud(random.nextInt(10)); System.out.println(++cpt + ") " + liste); } }.start();

55 Semaphore (9) new Thread() { public void run() { int cpt = 0; while (true) { liste.supprimerNoeud(random.nextInt(10)); System.out.println(++cpt + ". " + liste); } }.start(); }

56 CyclicBarrier : théorie CyclicBarrier(int nbParties); CyclicBarrier(int nbParties, Runnable action); int await(); // à faire nbParties fois pour quaction démarre (existe aussi avec un timeout) reset(); // pour réutiliser la barrière

57 CyclicBarrier (1) public class SommeLigne extends Thread { private int[] ligne; private int[] résultat; private int indice; private CyclicBarrier barrier; public SommeLigne(CyclicBarrier barrier, int[] ligne, int[] res, int idx) { this.barrier = barrier; this.ligne = ligne; this.résultat = res; this.indice = idx; } public void run() { for (int i = 0; i < ligne.length; i++) résultat[indice] += ligne[i]; try { barrier.await(); } catch (InterruptedException e) { } catch (BrokenBarrierException e) { }

58 CyclicBarrier (2) public class Somme implements Runnable{ private int[] résultats; private int somme; public Somme(int[] résultats) { this.résultats = résultats; } public void run() { for (int i = 0; i < résultats.length; i++) somme += résultats[i]; System.out.println("La somme vaut : " + somme); }

59 CyclicBarrier (3) public class Main { public static void main(String[] args) { int [][] matrice = { { 1 }, { 2, 2 }, { 3, 3, 3 }, { 4, 4, 4, 4 }, { 5, 5, 5, 5, 5 } }; int nbLignes = matrice.length; int [] résultats = new int[nbLignes]; CyclicBarrier barrier = new CyclicBarrier(nbLignes, new Somme(résultats)); for (int i = 0; i < nbLignes; i++) new SommeLigne(barrier, matrice[i], résultats, i).start(); }

60 CountDownLatch : théorie CountDownLatch(int compteur); void await(); // attends quon ait fait compteur countdown() (existe aussi avec un timeout) void countdown(); // à faire compteur fois pour terminer

61 CountDownLatch (1) public class SommeLigne extends Thread { private int[] ligne, résultat; private int indice; private CountDownLatch startLatch, stopLatch; public SommeLigne(CountDownLatch startLatch, CountDownLatch stopLatch, int[] ligne, int[] res, int idx) { this.startLatch = startLatch; this.stopLatch = stopLatch; this.ligne = ligne; this.résultat = res; this.indice = idx; } public void run() { try { startLatch.await(); } catch (InterruptedException e1) { } for (int i = 0; i < ligne.length; i++) résultat[indice] += ligne[i]; stopLatch.countDown(); }

62 CountDownLatch (2) public class Main { public static void main(String[] args) { int [][] matrice = { { 1 }, { 2, 2 }, { 3, 3, 3 }, { 4, 4, 4, 4 }, { 5, 5, 5, 5, 5 } }; int nbLignes = matrice.length; int [] résultats = new int[nbLignes]; CountDownLatch startLatch = new CountDownLatch(1); CountDownLatch stopLatch = new CountDownLatch(nbLignes); for (int i = 0; i < nbLignes; i++) new SommeLigne(startLatch, stopLatch, matrice[i], résultats, i).start(); startLatch.countDown(); try { stopLatch.await(); } catch (InterruptedException e) { } new Thread(new Somme(résultats)).start(); }

63 Callable Semblable à Runnable ne définit pas de run() mais une méthode V call(); on lutilisera avec une FutureTask

64 Callable public class SommeCall implements Callable { private int[] résultats; private int somme; public SommeCall(int[] résultats) { this.résultats = résultats; } public Integer call() throws Exception { for (int i = 0; i < résultats.length; i++) somme += résultats[i]; return somme; }

65 FutureTask : théorie implémente Runnable et Future FutureTask (Callable callable); FutureTask (Runnable runn, V résultat); void run() appelle call() de callable ou run() de runn V get() attend la fin de run puis renvoie le résultat de call ou celui passé en paramètre isDone(); cancel(); isCancelled();

66 FutureTask (1) utilisation avec une CyclicBarrier : FutureTask ft = new FutureTask ( new SommeCall(résultats)));; barrier = new CyclicBarrier(nbLignes, ft); for (int i = 0; i < nbLignes; i++) new SommeLigne(barrier, matrice[i], résultats, i).start(); try { System.out.println("la somme = " + ft.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); }

67 FutureTask (2) utilisation seule après lemploi dun CountDownLatch par exemple : FutureTask ft = new FutureTask ( new SommeCall(résultats)); ft.run(); // ou new Thread(ft).start(); try { System.out.println("la somme = " + ft.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); }

68 Exchanger : théorie Exchanger() V exchange(V valeur) attend quun autre thread appelle exchange sur cet Exchanger et échange les valeur des deux threads existe aussi avec un timeout

69 Exchanger > Un producteur remplit un buffer dentier. Quand il est plein, il échange ce buffer avec un consommateur. Un consommateur vide un buffer plein Quand il est vide il échange son buffer avec celui du producteur Voir code sur lextranet

70 Executor et ExecutorService : théorie Executor : Interface qui ne définit quune seule méthode –void execute(Runnable runnable); ExecutorService : Interface, extends Executor – List > invokeAll(Collection > tasks); – List > invokeAny(Collection >tasks); – Future submit(Callable task); –Future submit(Runnable task); – Future submit(Runnable task, T résultat); –void shutdown();

71 Executor, ExecutorService : exemple class NetworkService { private final ServerSocket serverSocket; private final ExecutorService pool; public NetworkService(int port, int poolSize) throws IOException { serverSocket = new ServerSocket(port); pool = Executors.newFixedThreadPool(poolSize); } public void serve() { try { for ( ; ; ) pool.execute(new Handler(serverSocket.accept())); } catch (IOException ex) { pool.shutdown(); } }

72 java.util.concurrent.locks définit les interfaces –Lock –Condition –ReadWriteLock fournit les implémentations –ReentrantLock –ReentrantReadWriteLock

73 Lock : théorie C'est une interface void lock(); // acquiert le lock void lockInterruptibly(); // de manière imterruptible Condition newCondition(); boolean tryLock(); // acquiert le lock s'il est libre boolean tryLock(long time, TimeUnit unit); // s'il devient libre dans le temps indiqué void unlock(); // libère le lock Elle est implémentée par la classe ReentrantLock Exemple : la classe Buffer dans producerconsumer

74 ReadWriteLock : théorie Cette interface fournit 2 méthodes : –Lock readLock(); –Lock writeLock(); Une classe qui l'implémente devra garder 2 locks –l'un partageable pour les opérations de lecture –l'autre exclusif pour les opérations d'écriture Java fournit une implémentation : la classe ReentrantReadWriteLock. Celle-ci possède 2 classes emboîtées : –ReentrantReadWriteLock.ReadLock –ReentrantReadWriteLock.WriteLock

75 ReentrantReadWriteLock : théorie (1) on ne peut acquérir le readLock que si le writeLock est libre on ne peut acquérir le writeLock que si le writeLock et le readLock sont libres si on a le writeLock on peut acquérir le readLock si on a le readLock, on ne peut pas acquérir le writeLock, on doit d'abord libérer le readLock si des lecteurs ont le readLock et qu'un rédacteur demande le writeLock, plus aucun autre lecteur n'obtiendra le readLock

76 ReentrantReadWriteLock : théorie (2) ReentrantReadWriteLock() ReentrantReadWriteLock(boolean fair) Si le lock est construit avec fair == true, quand un writeLock est libéré, le writeLock sera accordé au rédacteur qui l'a demandé depuis le plus longtemps, à moins qu'il n'y ait des lecteurs qui attendent depuis encore plus longtemps auquel cas l'ensemble des lecteurs acquérra le readLock Exemple : RWLockCoordinator de readerwriter

77 Prévention des deadlocks Un deadlock aura lieu uniquement si 4 conditions sont réalisées : –Exclusion mutuelle –Non préemption –Hold and Wait –Circularité Pour prévenir un deadlock, on doit –soit empêcher la circularité, par exemple en ordonnant les ressources –soit empêcher le Hold and Wait, par exemple en acquérrant toutes les ressources simultanément ou en utilisant le Two Phase Locking Exemples : le dîner des philosophes : voir philosophes


Télécharger ppt "La programmation concurrente en Java Les Threads."

Présentations similaires


Annonces Google