Généralités
En java une tâche est un processus léger :
il partage l’espace mémoire de l’application qui l’a
lancé.
il possède sa propre pile d’exécution.
En Java, un processus léger peut être créé
par :
1. dérivation de la classe Thread.
2. implémentation de l’interface Runnable.
Documentation officielle de Sun :
[Link]
Langage Java – Threads et synchronisation 2
Thread
Un thread est constitué essentiellement d’une
méthode run ()
Cette méthode est appelée par la méthode
start()
Un Thread vit jusqu’à la fin de l’exécution de sa
méthode run.
Un thread peut être endormi par sleep(nb de ms)
Un thread peut passer son tour par yield()
Un thread peut se mettre en attente par wait()
Langage Java – Threads et synchronisation 3
Création de Thread par spécialisation
de la classe Thread
Définition du thread
class MonThread extends Thread{
MonThread(. . .){
Constructeur
}
public void run(){
. . . Algorithme décrivant
le comportement du thread
}
. . .
}
Démarrage du thread
MonThread mt = new MonThread ();
[Link]() // exécute la méthode run de mt
Langage Java – Threads et synchronisation 4
Création de Thread par spécialisation
de la classe Thread
Exemple
class MaPremiereTache extends Thread {
public MaPremiereTache() {
super();
}
public void run() {
[Link](“Bonjour le monde !”);
}
}
...
MaPremiereTache t = new MaPremiereTache ();
[Link](); // exécute la méthode run de t
Langage Java – Threads et synchronisation 5
Création de Thread par implémentation
de l’interface Runnable
L’interface Runnable
public abstract interface
Runnable {
public abstract void run();
}
Utilisation
public class MaPremiereTache implements Runnable {
...
public void run() {
[Link](“Bonjour le monde !”);
}
}
Langage Java – Threads et synchronisation 6
Création de Thread par implémentation
de l’interface Runnable
Création d’une tâche à partir d’un objet Runnable
Runnable maTache = new MaPremiereTache(...);
Thread leThread = new Thread(maTache);
[Link](); // démarrage
ou simplement (tâche anonyme)
Runnable maTache = new MaPremiereTache(...);
new Thread(maTache).start();
ou encore...
MaPremiereTache maTache = new MaPremiereTache(...);
new Thread(maTache).start();
Langage Java – Threads et synchronisation 7
Méthodes statiques
Elles agissent sur le thread appelant
[Link](long ms)
bloque le thread appelant pour la durée
spécifiée;
[Link]()
Le thread appelant relâche le CPU au profit d’un
thread de même priorité;
[Link]()
retourne une référence sur le thread appelant;
Langage Java – Threads et synchronisation 8
Méthodes d’instances
MonThread p = new MonThread ();
[Link]() démarre le thread p;
[Link]() détermine si p est vivant (ou terminé);
[Link]() bloque l’appelant jusqu’à ce que p soit terminé;
[Link]() attache l’attribut « daemon » à p;
[Link](int pr) assigne la priorité pr à p;
[Link]() retourne la priorité de p;
…(beaucoup d’autres)
Langage Java – Threads et synchronisation 9
Arrêt d’une tâche
Un Thread dans l’état bloqué ou en attente peut être
arrêté par interrupt()
class MonThread extends Thread{
. . .
public void run(){
try{
while (true){
. . .
sleep(100);
}
}catch(InterruptedException ie){
. . .
}
} MonThread t = new MonThread ();
. . .
} [Link]();
. . .
[Link]();
Langage Java – Threads et synchronisation 12
Arrêt d’une tâche
public void run() {
try {
// Corps de la tâche
...
} catch (InterruptedException e) {
// Terminer la tâche
...
return;
} finally {
// Code exécuté avant la fin de la tâche, quelle que soit
// la cause qui l’a arrêtée (fin normale ou exception
// ou erreur)
...
}
}
Langage Java – Threads et synchronisation 14
Jointure de threads
Un thread peut avoir à attendre la fin d’un ou
plusieurs threads pour démarrer : join()
class MonThread extends Thread{
Thread precedent;
public MonThread( Thread p){
précédent = p;
}
public void run(){
try{
[Link](); // le thread reste bloqué tant que
// precedent n’est pas terminé
. . .
}catch(InterruptedException ie){
. . .
}
}
}
Langage Java – Threads et synchronisation 15
Priorité des threads
Les Threads ont une priorité qui va de
Thread.MIN_PRIORITY (1)
Thread.NORM_PRIORITY (5)
Thread.MAX_PRIORITY (10)
int getPriority() ;
void setPriority(int p) ;
void setDaemon(boolean on) permet de rendre un
thread démon : thread qui s’exécute en tâche de
fond.
Un programme Java se termine lorsque tous les threads user
sont terminés (les threads daemon n’ont pas besoin d’être
terminés).
Langage Java – Threads et synchronisation 16
Threads de la JVM
En plus des threads du programme Java,
une machine virtuelle Java exécute des
threads dédiés à des tâches de gestion :
thread oisif (priorité 0): exécuté si aucun autre thread ne
s’exécute;
ramasse-miettes (garbage collector, priorité 1): récupère les
objets qui ne sont plus accessibles (référencés). Ce thread ne
s’exécute que lorsqu’aucun autre thread (à part le thread oisif)
ne s’exécute;
gestionnaire d’horloge: gère tous les événements internes liés
au temps;
thread de finalisation: appelle la méthode finalize( ) des objets
récupérés par le ramasse-miettes.
Langage Java – Threads et synchronisation 17