Vous êtes sur la page 1sur 3

Université Ibn Khaldoun – Tiaret Module : Systèmes d’Exploitation II (TP)

Niveau : 3 LMD Version : 3.00


Département d’Informatique Chargé du module : B.B

Fiche TP N° 05
« Manipulation des Threads en langage Java »
Remarques:
 Gestion lourde des threads avec C (API POSIX) et simplifiée avec Java.
 En java, les threads sont des instances des classes dérivées (héritées) de la classe Thread
 La classe Thread crée des threads généraux, sa méthode run ne fait rien.
 La méthode run indique à un thread les instructions à exécuter
 La méthode run doit être publique, ne prendre aucun argument, ne renvoyer aucune
valeur et ne lever aucune exception.
 Deux techniques pour fournir une méthode run à un thread
1) hériter la classe Thread (java.lang.Thread) et redéfinir la méthode run.
2) Implémenter l’interface Runnable (java.lang.Runnable) et définir la méthode run de
cette classe
 Un thread commence par exécuter la méthode run de l’objet “cible” qui a été passé au thread.

Exercice 1 : Technique n°1 : Hériter la classe Thread

Thread1.java
class TPrint extends Thread
{
String txt;
int attente;
public TPrint(String t, int p)
{ txt= t; attente=p;}
public void run (){ for (int i=0 ; i<8;i++) {
System.out.print (txt+i+" ");
try {
sleep(attente);
}
catch (InterruptedException e) {};
}
}
}
public class Thread1 {
static public void main(String args[]){
TPrint a= new TPrint("A", 100); // créer un thread
TPrint b= new TPrint("B", 200); // créer un autre thread
a.start();
b.start();
}
}

N.B:
Le Résultat des deux exercices devrait être : A0 B0 A1 A2 B1 A3 A4 B2 A5 A6 B3 A7 B4 B5 B6 B7

Question: Donner une explication de ce résultat ?

1
Exercice 2 : Technique n°2 : Implémenter l'interface Runnable

Thread2.java
import java.io.*;
import java.lang.*;
class TPrint implements Runnable {
String txt;
int attente;
public TPrint (String t, int p)
{ txt= t; attente=p;}
public void run (){ for (int i=0 ; i<8;i++) {
System.out.print (txt+i+" ");
try {
Thread.currentThread().sleep(attente);
}
catch (InterruptedException e) {};
}
}
}
public class Thread2 {
static public void main(String args[]){
TPrint a= new TPrint("A", 100);
TPrint b= new TPrint("B", 200);
new Thread(a).start(); // Créer et lancer un thread
new Thread(b).start();
}
}

Exercice 3 : Soit 2 threads qui comptent de 1 à 10 et à 15. Commençons donc par créer une sous-classe
de la classe Thread, puis créons une classe permettant de lancer les deux threads via la méthode main() :

LanceCompteurs.java
import java.io.*;
import java.lang.*;

class ThreadCompteur extends Thread {


int no_fin;
// Constructeur
ThreadCompteur(int fin) {
no_fin = fin;
}
// On redéfinit la méthode run()
public void run() {
for (int i=1; i<=no_fin ; i++) {
System.out.println(this.getName()+"==>"+i);
}
}
}
// Classe lançant les threads
class LanceCompteurs {
public static void main (String args[]) {
// On instancie les threads
ThreadCompteur cp1 = new ThreadCompteur(10);
ThreadCompteur cp2 = new ThreadCompteur(15);

2
// On démarre les deux threads
cp1.start();
cp2.start();
// On attend qu'ils aient fini de compter
while (cp1.isAlive() || cp2.isAlive()) {
// On bloque le thread 100 ms
try {
Thread.sleep(100);
} catch (InterruptedException e) { return; }
}
}
}

Le résultat devrait être similaire à ce qui suit :

Thread-0==>1
Thread-1==>1
Thread-0==>2
Thread-1==>2
Thread-0==>3
Thread-1==>3
Thread-0==>4
Thread-1==>4
Thread-0==>5
Thread-1==>5
Thread-0==>6
Thread-1==>6
Thread-0==>7
Thread-1==>7
Thread-0==>8
Thread-1==>8
Thread-0==>9
Thread-1==>9
Thread-0==>10
Thread-1==>10
Thread-1==>11
Thread-1==>12
Thread-1==>13
Thread-1==>14
Thread-1==>15

Question : Donner une explication de ce résultat ?

Rappel :

1) Pour compiler un programme java (par exemple, exemple.java) :


javac exemple.java
qui va générer exemple.class (le bytecode de ce programme)
2) Pour l’exécuter :
java exemple
3

Vous aimerez peut-être aussi