Les threads

Prsent par:
EL GHARDEGUE
Souad
Encadr par:
LOTFI Hicham

Les threads:
Les threads sont des fils d'excution dun
programme. Lorsque nous en crons plusieurs,
nous pouvons excuter des tches
simultanment.
Il existe deux faons de crer un nouveau
thread.
Crer une classe hritant de la classe Thread

Crer une implmentation de l'interface

Runnable et instancier un objet Thread avec
l'implmentation de cette interface.

Une classe hrite de Thread

Le plus simple pour dfinir un
thread est de crer une classe qui
hrite de la classe java.lang.Thread.
Il suffit alors simplement de
redfinir la mthode run() pour y
inclure les traitements excuter
par le thread.

Exemple :
Voici un programme qui va lancer trois
threads simples, chacun dentre eux se
contentantdafficher un certain nombre de
fois un texte donn, savoir :
10 fois "bonjour" pour le premier thread,
12 fois "bonsoir" pour le deuxime
thread,
5 fois un changement de ligne pour le
troisime thread.

Exemple :
class Ecrit extends Thread
{ public Ecrit (String texte, int nb)
{ this.texte = texte ;
this.nb = nb ;
}
public void run ()
{ for (int i=0 ; i<nb ; i++)
System.out.print (texte) ;
}

Exemple :
public static void main(String[] args) {
Ecrit e1 = new Ecrit ("bonjour", 10) ;
Ecrit e2 = new Ecrit ("bonsoir", 12) ;
Ecrit e3 = new Ecrit ("\n", 5) ;
e1.start() ;
e2.start() ;
e3.start() ;
}

Utilisation de linterface Runnable

Cette

interface doit tre implmente par

toute classe qui contiendra des
traitements excuter dans un thread.
Cette interface ne dfinit qu'une seule
mthode: void run().
Dans les classes qui implmentent cette
interface, la mthode run() doit tre
redfinie pour contenir le code des
traitements qui seront excuts dans le
thread.

Exemple :
class Ecrit implements Runnable
{ public Ecrit (String texte, int nb, long attente)
{ this.texte = texte ;
this.nb = nb ;
this.attente = attente ;
}
public void run ()
{ try
{ for (int i=0 ; i<nb ; i++)
{ System.out.print (texte) ;
Thread.sleep (attente) ; // attention Thread.sleep
}
}
catch (InterruptedException e) {} // impose par sleep
}
private String texte ;
private int nb ;
private long attente ;}

Exemple :
public class TstThr3
{
public static void main (String args[])
{
Ecrit e1 = new Ecrit ("bonjour ", 10, 5) ;
Ecrit e2 = new Ecrit ("bonsoir ", 12, 10) ;
Ecrit e3 = new Ecrit ("\n", 5, 15) ;
Thread t1 = new Thread (e1) ;
t1.start() ;
Thread t2 = new Thread (e2) ;
t2.start() ;
Thread t3 = new Thread (e3) ;
t3.start() ;
}
}

Cycle de vie d'un thread

1. tat nouveau
C'est l'tat initial aprs l'instanciation du
thread. ce stade, le thread est oprationnel,
mais celui-ci n'est pas encore actif.
Un thread prend cet tat aprs son instanciation.
2. tat excutable
Un thread est dans un tat excutable partir du
moment o il a t lanc par la mthode start()
et le reste tant qu'il n'est pas sorti de la mthode
run().
Ds que le systme le pourra, il donnera du
temps d'excution votre thread.

Cycle de vie d'un thread

3. tat en attente
Un thread en attente est un thread qui n'excute
aucun traitement et ne consomme aucune ressource
CPU. Il existe plusieurs manires de mettre un thread
en attente. Par exemple : appeler la mthode
thread.sleep (temps en millisecondes)
4. tat mort
Un thread dans un tat mort est un thread qui est
sorti de sa mthode run() soit de manire naturelle,
soit de manire subite .

Vie et mort d'un thread

Activation : la mthode start() appelle la mthode run()

(start() n'est pas bloquante dans le thread appelant).

Destruction : elle intervient quand la mthode run() se

termine.
Il est possible d'interrompre le thread en utilisant la
mthode interrupt()

qui cre une

InterruptedException si le thread est en attente.

Sommeil d'un thread

Thread.sleep(long millis) est une
mthode de classe qui met le
thread courant en sommeil un certain
nombre de millisecondes.
Cette mthode peut lever une exception de
type InterruptedException si le thread est
ractiv avant la fin du temps.

Priorits entre threads:

Une valeur de priorit est affecte chaque thread et dtermine sa priorit
d'accs au temps CPU.

Les Threads ont une priorit qui va de

Thread.MIN_PRIORITY
Thread

(1)

NORM PRIORITY (5) .NORM_PRIORITY (5)

Thread.MAX_PRIORITY (10)

La priorit est modifie par setPriority(int i) et accde par int

getPriority():

Exercice :
Un "compteur" a un nom (Toto par exemple) et il
compte de 1 n (nombre entier positif quelconque).
Il marque une pause alatoire entre chaque nombre
(de 0 5000 millisecondes par exemple). Un
compteur affiche chaque nombre (Toto affichera par
exemple, "Toto : 3") et il affiche un message du type
"*** Toto a fini de compter jusqu' 10" quand il a
fini.
Ecrivez la classe compteur et testez-la en lanant
plusieurs compteurs qui comptent jusqu' 10. Voyez
celui qui a fini le plus vite.

Correction :
public class Compteur extends Thread {
String nom;
int max;
public Compteur(String nom, int max) {
this.nom = nom;
this.max = max; }
public Compteur(String nom)
{this.nom = nom;
this.max = 10; }

public void run() {

for (int i = 1; i <= max; i++) {
try {
sleep((int)(Math.random() * 5000));
}
catch(InterruptedException e)
{
System.err.println(nom + " a ete interrompu.");
}
System.out.println(nom + " : " + i);
}
System.out.println("*** " + nom + " a fini de compter
jusqu' " + max); }

public static void main(String[] args)

{ Compteur c1 = new
Compteur("JAVA",3);
Compteur c2 = new Compteur("UML");
Compteur c3 = new Compteur("AGL",15);
c1.start();
c2.start();
c3.start();
} }