Threads

Conceptuellement les threads ressemblent à des processus, à la différence que plusieurs threads partagent le même espace d'adressage, se qui signifie qu'ils peuvent partager des variables et des méthodes (en possédant en même temps ses propres variables locales).

Les threads sont plus économes en ressources si on les compare au processus, donc il est concevable pour une seule application de lancer des centaines de threads en même temps

 Мultiprocessing et Multithreading

Мultiprocessing - deux ou plusieurs programmes qui s'exécutent "visiblement" de manière compétitive sous le contrôle du système d'exploitation. Les programmes n'ont aucun lien entre eux, sauf le fait qu'ils sont démarrés et exécutés simultanément. Il est mis en œuvre par le système d'exploitation et aucune mesure ne doit être prise au sein du programme.

Multithreading - deux ou plusieurs tâches qui sont effectuées "visiblement" en parallèle dans le même programme. Parfois appelés processus « légers »
Bien qu'il nécessite une maintenance du système d'exploitation, il est implémenté et exécuté par le programme lui-même. la conception et la planification de programmes spéciaux sont nécessaires

Caractéristiques

• Les threads en Java sont des objets de la classe Thread qui fait partie du package java.lang.
• Lors de la création d'un nouveau thread, il est nécessaire de redéfinir la méthode run(), et toutes les fonctionnalités du thread sont intégrées dans cette méthode.
• La méthode run() peut appeler d'autres méthodes.
• Le thread est démarré en appelant la méthode start() de l'objet correspondant.
• La méthode start(), à son tour, appelle la méthode run() et prend en charge toutes les tâches supplémentaires nécessaires.
• Aucune de ces méthodes ne possede pas de paramètres.
• De nombreuses classes Thread différentes et de nombreux objets différents de la même classe Thread peuvent être utilisés dans un même programme.
• Chacune de ces classes a sa propre méthode run(), qui est indépendante des méthodes run() des autres classes

Constructeurs

Quelques méthodes  utilisées souvent

3.1 Creation d'une Thread 

            Dériver la classe Thread
La programmation avec les threads a des particularités surtout avec la synchronisation des threads. Java a des utiles simples pour résoudre bon nombre de problèmes.

Les threads sont créés et contrôlé par les objets de la classe Thread.

Chaque objet de ce classe correspond à un seul thread. Il contient des méthodes pour lancer, contrôler et arrêter l'exécution du thread. Pour lancer l'exécution  d'un thread on doit appeler la méthode start() de la classe Thread. Une fois que le thread est lancé, il continue à s'exécuter jusqu'à la fin du traitement (indiqué par la méthode run() ) ou jusqu'à ce que la méthode stop() le termine.

Le traitement qui doit être effectué par le thread est indiqué par une méthode appelée run(). On a deux possibilités pour spécifier la méthode run(). Premièrement, la classe Thread elle-même possède une méthode run(). On peut dériver la classe Thread et de redéfinir sa méthode run() pour faire ce que l'on veut. Dans ce cas on crée une instance de la classe dérivée et on lance sa méthode start().

        Implémenter Runnable
Il n'est pas toujours possible de créer une classe dérivée de la classe Thread. Par exemple une applet doit être dérivée de la classe Applet, donc elle ne peut pas être dérivée en même temps de la classe Thread. Dans ce cas on a besoin d'indiquer à la classe Thread quel objet possède la méthode run() qu'il doit exécuter. La classe Thread possède un constructeur qui prend comme argument une référence sur un objet. Si on crée un objet thread en utilisant ce constructeur et si on appelle sa méthode start() le thread va exécuter la méthode run() de l'objet passé en paramètre plutôt que la sienne. Pour effectuer cette opération, Java a besoin d'avoir garantie que l'objet que nous passons en paramètre contient une méthode run().

 

Création o La classe java. lang. Thread permet de créer de nouveaux threads o un thread doit implémenter obligatoirement l’interface Runnable         - le code exécuté se situe dans sa méthode run() o 2 méthodes pour créer un Thread :     - 1) une classe qui dérive de java. lang. Thread             -- java. lang. Thread implémente Runnable             -- il faut redéfinir la méthode run()     - 2) une classe qui implémente l’interface Runnable             -- il faut implémenter la méthode run()

Dériver la  classe Thread o Méthode 1 : une sous - classe de Thread class Proc1 extends Thread { Proc1() {...} // Le constructeur ... public void run() { ... // Ici ce que fait le processus : boucle infinie } } ... Proc1 p1 = new Proc1(); // Création du processus p1 p1.start(); // Demarre le processus et execute p1. run()

Implémenter Runnable o Méthode 2 : une classe qui implémente Runnable class Proc2 implements Runnable { Proc2() { ...} // Constructeur ... public void run() { ... // Ici ce que fait le processus } } ... Proc2 p = new Proc2(); Thread p2 = new Thread( p); ... p2.start(); // Démarre un processus qui execute p. run()

Quelle solution choisir ? o Méthode 1 : sous- classer Thread     - lorsqu’on désire paralélliser une classe qui n’hérite pas déjà       d’une autre classe (attention : héritage simple)     - cas des applications autonomes o Méthode 2 : implémenter Runnable     - lorsqu’une super- classe est imposée     - cas des applets public class MyThreadApplet extends Applet implements Runnable {}

3.2 Etats d'un thread (Cycle de vie)

 4 états:  New , Runnable, Blocked, Dead .

Méthode isAlive()

La classe Thread possede un méthode isAlive()

•  isAlive() retourne true, dans l'état running ou bien blocked
• isAlive() retourne false, dans l'état  new oubien dead.

Méthode getState()

Après release 5.0 existe la méthode Thread.getState() qui a pour résultat une de  cettes Thread.State valeurs:

• NEW
• RUNNABLE
• BLOCKED
• WAITING
• TIMED_WAITING
• TERMINATED

Une exemple simple
 

Dériver la classe Thread

    3.3.1

• une liste des threads à executer est créée. 
• un nouveau thread est ajouté en fin de liste ;
• l'utilisation par un thread du processeur ne peut pas dépasser un certain quantum de temps ;
• l'attente maximum est donnée par la multiplication du nombre de threads en cours multiplié par le quantum de temps accordé à chaque thread (NB : Chaque thread dispose du même quantum de temps que les autres) ;
• un thread qui vient de finir d'utiliser le processeur (quantum écoulé) est placé en fin de liste ;
• un thread qui a terminé son travail est sorti de la liste, par conséquent le temps d'attente pour les autres threads diminue.

    3.3.3 Avec des priorités

Chaque thread a la priorité (le droit de commencer avant les autres). Les priorités sont représentées par des entiers allant de Thread.MAX_PRIORITY (10 - le plus élevé) à Thread.MIN_PRIORITY (1 - le plus bas). Par défaut, chaque thread a la même priorité que celui qui l'a créé. Une fois la priorité du thread créée, vous pouvez la modifier à l'aide de la méthode setPriority ().

    3.3.4 Exemple avec modification des priorités:

import java.text.*; import java.util.*; //: SimpleThreadPr.java public class SimpleThreadPr extends Thread {     private int countDown = 5;     private String name;     private static Date dt = new Date( );     private static DateFormat df = new SimpleDateFormat("HH:mm:ss:SSS");     private volatile double d=0; // no optimization     public SimpleThreadPr(String name, int prior) {         this.name = name;         setPriority(prior);         System.out.println("\t\tMaking " + name);     }     public void run() {         dt.setTime(System.currentTimeMillis( ));         System.out.println(name+"start at "+df.format(dt)+"pr -> "+getPriority());         for( ;countDown>0; countDown--) {             // An expensive, interruptible operation:             for(int i = 1; i < 100000; i++)                 d = d + (Math.PI + Math.E) / (double)i;             System.out.println("Thread " + name + "(" + countDown + ")"+                     " priority -> " + getPriority() );         }         System.out.println("Thread " + name + " end");     }     public static void main(String[] args) {         String nameA[]={"Nick", "Marie", "George", "Isabelle", "Pierre","Rose","Salome"};         SimpleThreadPr st[] = new SimpleThreadPr[nameA.length];         for(int i = 0; i < nameA.length; i++)             st[i] = new SimpleThreadPr(nameA[i],i<3?Thread.MAX_PRIORITY:                 Thread.MIN_PRIORITY);         for(int i = 3; i < nameA.length; i++)             st[i] .start();         System.out.println("\t\tThe Threads with low priority started");         for(int i = 0; i < 3; i++)             st[i] .start();         System.out.println("\t\tAll Threads Started");     } }

Making Nick         Making Marie         Making George         Making Isabelle         Making Pierre         Making Rose         Making Salome         The Threads with low priority started         All Threads Started Nickstart at 09:49:37:705pr -> 10 Rosestart at 09:49:37:705pr -> 1 Isabellestart at 09:49:37:705pr -> 1 Pierrestart at 09:49:37:705pr -> 1 Salomestart at 09:49:37:705pr -> 1 Mariestart at 09:49:37:705pr -> 10 Georgestart at 09:49:37:705pr -> 10 Thread Nick(5) priority -> 10 Thread Marie(5) priority -> 10 Thread George(5) priority -> 10 Thread Isabelle(5) priority -> 1 Thread Marie(4) priority -> 10 Thread Pierre(5) priority -> 1 Thread Rose(5) priority -> 1 Thread Salome(5) priority -> 1 Thread George(4) priority -> 10 Thread Nick(4) priority -> 10 Thread Marie(3) priority -> 10 Thread Nick(3) priority -> 10 Thread Rose(4) priority -> 1 Thread Isabelle(4) priority -> 1 Thread Pierre(4) priority -> 1 Thread Marie(2) priority -> 10 Thread George(3) priority -> 10 Thread Nick(2) priority -> 10 Thread Rose(3) priority -> 1 Thread Salome(4) priority -> 1 Thread Isabelle(3) priority -> 1 Thread Marie(1) priority -> 10 Thread Marie end Thread George(2) priority -> 10 Thread Rose(2) priority -> 1 Thread Nick(1) priority -> 10 Thread Nick end Thread Pierre(3) priority -> 1 Thread George(1) priority -> 10 Thread George end Thread Salome(3) priority -> 1 Thread Isabelle(2) priority -> 1 Thread Pierre(2) priority -> 1 Thread Rose(1) priority -> 1 Thread Rose end Thread Pierre(1) priority -> 1 Thread Pierre end Thread Salome(2) priority -> 1 Thread Isabelle(1) priority -> 1 Thread Isabelle end Thread Salome(1) priority -> 1 Thread Salome end

 
Remarque: En principe il y a des différentes approches de combiner  "round robin" avec des priorités dans les différents JVM pour éviter le risque de "starving".   D'une manière générale, il n'est guère conseillé d'agir sur les priorités des threads dans les programmes qui se veulent portables!

    Implémenter Runnable

    3.3.5 On peut utiliser un Thread qui travail tous le temps: 

    3.3.6. Ou bien créer et tuer le Thread chaque fois:

3.3.7 Lancement de plusieurs threads