les “threads” Java

Iremia, R.Courdier
03/27/99 1
© Rémy Courdier 1996-2003 - le multitache Java - Version du cours 2.8 1
Chapitre 6 : Processus Légers
les “threads”
Java
© Rémy Courdier 1996-2003 - le multitache Java - Version du cours 2.8 2
Sommaire
Les Threads
Utilité des processus légers
La Classe Thread et l’interface Runnable
Implémentation de Runnable
Spécialisation de la classe Thread
Les démons
Le partage de ressources
Bloquer un processus
Les groupes de thread

Iremia, R.Courdier
03/27/99 2
© Rémy Courdier 1996-2003 - le multitache Java - Version du cours 2.8 3
Threads
Utilité des processus légers
Creer des processus séparés,
“indépendants”
Accéder à la programmation
concurrente (parallèle)
implémenter des mécanismes de
synchronisation et de rendez-vous
gérer des interfaces utilisateurs
sophistiquées
créer des serveurs de réseaux
gestion de graphiques animés
Masquer la complexité des
mécanismes de “time slicing”
2 techniques
Implémenter l’interface Runnable
class x implements Runnable
{
//corps de classe
}
hériter de la classe Thread
class x extends Thread
{
//corps de classe
}
© Rémy Courdier 1996-2003 - le multitache Java - Version du cours 2.8 4
Threads
implémentation de Runnable
L’interface Runnable
Une seule fonction run() :
invoquée par la méthode start()
de la classe Thread
Ne permet la création que
d’une Thread pour une
instances de classe donnée
La classe qui implémente
Runnable n’a pas de
possibilités de multi-processing
Il faut qu’elle gere la création d’une
instance de Thread qui prend en
argument un objet “Runnable”
Il faut ensuite appeler start()
sur le thread
le start() appelera alors run()
/** Fichier Runnable.java */
...
public class T1 extends applet
implements Runnable {
Thread selfThread = null;
...
public void run() {
while(true){...
try {
Thread.currentThread().sleep(50);
} catch(Exception e) {}
...}
}
...
public void declencheThread() {
if (selfThread == null) {
selfThread = new Thread(T1.this);
selfThread.start();
}
}
}

Iremia, R.Courdier
03/27/99 3
© Rémy Courdier 1996-2003 - le multitache Java - Version du cours 2.8 5
Threads
spécialisation de la classe Thread
Technique pour creer plusieurs
threads associées à une
instance d’une classe C
On cree une autre classe T
gérée par la classe C
La classe T hérite de Thread
avec les mécanismes de multi-
processus
Technique plus générale et
plus ouverte que l’interface
Runnable : il est conseillé en
règle générale de l’utiliser
la classe T peut être définie
comme une inner classe
/** Fichier tabThread.java */
...
class T extends Thread {
...
public void run() {
while(true){...
try {
Thread.currentThread().sleep(50);
} catch(Exception e) {}
...}
}
public class C extends Applet {
T tabT[] = new T()[10];
public void init() {...
for (int i;...) s[i]start();
}
...
}
© Rémy Courdier 1996-2003 - le multitache Java - Version du cours 2.8 6
Thread
Les démons
Processus s’exécutant en tache
de fond tant que le programme
tourne
Un démon “meurt” lorsque
l’application se termine
Méthodes sur les démons :
boolean isDeamon(Thread)
void setDeamon(boolean)
Déclaration :
Dans le constructeur (en général) on
possitionne le thread comme étant un
démon :
MaClasseDeamon() {
setDeamon(true);
start();
}
THREAD
DU
MAIN()
THREAD DÉMONS
AUTRES
THREADS DE
L’APPLI

Iremia, R.Courdier
03/27/99 4
© Rémy Courdier 1996-2003 - le multitache Java - Version du cours 2.8 7
Les Threads
Le partage de ressources
Java intègre dans le langage lui-même des éléments de langage
pour gérer le partage de ressources
utilisation du mot clé synchronized
synchronized void f() { /*...*/ }
synchronized void g() { /*...*/ }
si f() est appelée pour une instance i ,
g() ne peut être appelée sur l’instance i tant que f() n’est pas terminée
il y a mise en place automatique d’un principe de vérouillage (lock) des
données de l’instance concernée
performance
un principe de verouillage est un mécanisme couteux
faire des fonctions synchronisées petites pour que le blockage soit le plus court
possible
attention aux problèmes de blockage temporaire de traitement
attention au DeadLock
© Rémy Courdier 1996-2003 - le multitache Java - Version du cours 2.8 8
Les thread
Bloquer un processus
Les 4 états d’un Thread :
New : l’objet thread est créé mais
n’est pas “started”
Runnable : Le “scheduler” prend en
compte cette tache dans son
allocation de temps CPU
Dead : sortie de la méthode run() ou
suite à l’invocation de la méthode
stop() (à éviter car déclenche une
exception)
Blocked : Le “scheduler” n’alloue pas
pas de temps CPU pour le processus
jusqu’à ce qu’elle redevienne
Runnable
Cas de blockage d’un Processus
sleep(milliseconds)
suspend()...
...resume()
wait()...
...notify() ou notifyAll()
attente de terminaison d’une
entrée/sortie
méthode synchronisée qui
block l’accés à l’instance

Iremia, R.Courdier
03/27/99 5
© Rémy Courdier 1996-2003 - le multitache Java - Version du cours 2.8 9
Les threads
Priorités
Java permet d’associer un niveau de priorité à chaque
thread
Cette information est exploitée par le scheduler lors de
son partage de temps CPU aux processus
Variable utiles
Thread.MAX_PRIORITY
Thread.MIN_PRIORITY
Par défaut la priorité est 5 en Java 1.1
Méthodes utiles :
getPriority()
setPriority()
© Rémy Courdier 1996-2003 - le multitache Java - Version du cours 2.8 10
Les thread
Les groupes de thread
Un thread appartient à un groupe
Par défaut un thread appartient au groupe “system”
Creation
public static void main (...) {...
ThreadGroup x = new ThreadGroup (“GroupeX”);
ThreadGroup y = new ThreadGroup (“GroupeY”);
Thread t1 = new T1(x, “t1”);
Thread t2 = new T2(y, “t2”);
}
...
class T1 extends Thread {
...
T1(ThreadGroup g, String name) {
super (g, name);
}
}