Première façon de faire: dériver java.lang.Thread.
public classe MonPremierThread extends Thread {
public void run() { ... }
}
L’appel à la méthode start (héritée) lance l’exécution de la méthode run. L’exécution du thread se termine au retour de la méthode run.
MonPremierThread t = new MonPremierThread();
monPremierThread.start();
L’héritage de java.lang.Thread est contraignant car il empêche tout autre héritage. Il existe une seconde façon de faire: implémenter l’interface java.lang.Runnable.
public classe MaClasseRunnable implements Runnable {
public void run() { ... }
}
On passe une instance de la classe implémentant Runnable au constructeur de Thread.
MaClasseRunnable r = new MaClasseRunnable();
Thread t = new Thread( r );
t.start();
Tous les threads ont accès au même espace mémoire. Quand les threads manipulent une référence vers un même objet, les accès concurrents au même objet sont suceptibles de génèrer des erreurs.
Pour les éviter, chaque objet a un verrou (intrinsic lock, monitor lock, monitor). Un thread qui veut un acces exclusif à un objet acquière ce verrou, puis le libère quand il a finit. Entre temps, il possède le verrou. Aucun autre thread ne peut alors acquérir le verrou de cet objet.
Quand un thread appelle une méthode synchronized d’un objet, il acquière son verrou et le relâche à la fin de l’exécution de la méthode.
synchronized typeRetour nomMethode(listeParametres) { ... }
On peut aussi écrire des blocs synchronized pour avoir un niveau plus fin et éviter un blocage non nécessaire.
synchronized (this) {
...
}
Modifiez les classes EvenCounter et EvenCounterTest de façon à ce que la valeur du compteur ne s’affiche que tant qu’elle est inférieure à 50. Utilisez le mot-clé synchronized a bon escient pour éviter les accès concurrents, tout en permettant aux deux threads de travailler.
Astuce: Préfixez les affichages par Thread.currentThread().getName().
Quand plusieurs threads partagent des données, il peut y avoir interférence (deux exécutions d’une même méthode sont entrelacées) ou incohérence (les appels de différentes méthodes d’un même objet sont entrelacés).
Pour éviter ces problèmes, on utilise le mot-clé synchronized.
Quand un thread appelle une méthode synchronized d’un objet ou exécute un bloc synchronized(this) dans une de ses méthodes, il acquière son verrou, et le relâche à la fin de l’exécution.
- start : active ce thread.
- run : exécute ce thread.
- interrupt : interromp ce thread.
- join : attend que ce thread se termine.
- sleep : endort ce thread durant un certain temps (en millisecondes).
- yield : ce thread rends la main.
Modifiez la classe EvenCounterTest de façon à faire afficher par le thread principal un message de fin sur la sortie standard.
Il peut y avoir plusieurs problèmes de concurrence:
- deadblock : chaque thread laisse passer l’autre (image de deux personnes qui n’avancent pas tant que l’une n’a pas fait le premier pas).
- liveblock : chaque thread réagit par rapport à l’autre (image de deux personnes qui ne parviennent pas à se croiser en faisant toutes deux un pas de même côté)
- starvation : un thread lent empêche les autres de faire leur travail.
Pour coordonner les threads, on implémente des commandes bloquantes avec les méthodes wait et notifiy(All) de java.lang.Object.
- wait: le thread courant doit posséder le verrou de l’objet (c’est pourquoi la méthode dans laquelle wait est appelée doit être déclarée synchronized). Il relâche le verrou et attends qu’un autre thread le réveille par notify(All) (ou qu’une durée donnée soit écoulée). Il attend ensuite d’obtenir le verrou pour poursuivre l’exécution.
- notifyAll: réveille tous les threads en attente sur l’objet.
- notify: réveille un seul thread, choisi arbitrairement.
NB: Une bonne pratique est d’appeler wait dans une boucle testant la condition attendue (myProduct == null ou myProduct != null), car le thread qui attends peut être réveillé par un thread quelconque alors que la condition attendue n’est pas vérifiée.
- Tous les objets peuvent mettre en attente le thread courant avec wait.
- Tous les objets peuvent réveiller le(s) thread(s) bloqué(s) par eux, avec notify(All).
Piscine piscine = new Piscine(); //la piscine
int n = 150;
Thread[] baigneurs = new Thread[n];
for (int i = 0; i < n; i++) //les baigneurs
baigneurs[i] = new Thread( new Baigneur(piscine, 5) );
Le package java.util.concurrent contient une classe Executors fabriquant:
Ces méthodes renvoient en fait un objet de type ExecutorService, sous-type de Executor. Autrement dit, un objet issu d’une classe implémentant l’interface ExecutorService, dérivant l’interface Executor.
Les objets de type Executor possèdent une méthode execute() qui crée, puis démarre un thread.
Si e est un objet de type Executor et si r est un objet de type Runnable, alors ces codes sont équivalents:
Thread t = new Thread(r);
t.start();
e.execute(r);