Un thread désigne un point d'exécution dans le programme. En fait, le langage Java est multi-thread, c'est à dire qu'il peut exécuter du code à plusieurs endroits de façon indépendante.
Exemple d'utilisation :
L'utilisation des threads est très fréquente dans la programmation réseau. Un client FTP peut télécharger plusieurs fichiers, naviguer sur plusieurs serveurs en même temps, chaque connexion étant gérée par un thread différent. Autre exemple : dans un traitement de texte, un thread s'occupe de ce que tape l'utilisateur, un autre est en charge de souligner les erreurs, un 3<sup>ème</sup> se charge de faire parler le trombone ! :-)
Créer un thread est très simple en Java. Deux solutions s'offrent à vous :
Dériver de la class Thread :
Vous pouvez créer une nouvelle classe qui dérive de la classe <javaClass class="java.lang.Thread" />. Il suffit ensuite de redéfinir la méthode <javaMethode class="java.lang.Thread" methode="run()" />. C'est cette méthode que le thread va exécuter.
Implémenter java.lang.Runnable :
Si vous ne souhaitez pas faire une classe dédiée à la gestion du processus, vous pouvez simplement implémenter l'interface <javaInterface class="java.lang.Runnable" /> et définir la méthode <javaMethode class="java.lang.Thread" methode="run()" />. Ensuite il suffit de créer un objet <javaClass class="java.lang.Thread" /> en lui passant la classe en paramètre.
Dans tous les cas :
Pour lancer l'exécution d'un thread vous devez exécuter la méthode <javaMethode class="java.lang.Thread" methode="start()" /> et en aucun cas exécuter vous-même la méthode <javaMethode class="java.lang.Thread" methode="run()" /> (L'exécution se déroulerait alors dans le processus courant !).
Pour les autres, toutes ces méthodes ont été marquées deprecated car, sous certaines conditions et sans qu'il y ait d'erreur de conception, l'application peut se bloquer. Typiquement, lorsqu'un thread est tué, il n'est pas possible de savoir ce qu'il était en train de faire, il est donc possible qu'il soit arrêté au milieu d'une modification d'un objet; cet objet est donc laissé dans un état incohérent. Des problèmes similaires peuvent se produire avec les méthodes suspend() et resume().
La méthode <javaMethode class="java.lang.Thread" methode="stop()" /> de la classe <javaClass class="java.lang.Thread" /> étant dépréciée, il est nécessaire de prévoir soit-même la possibilité d'arrêter le processus.
Squelette standard d'un Thread
Ce squelette permet de facilement arrêter le processus sans utiliser la méthode dépréciée <javaMethode class="java.lang.Thread" name="stop()" />.
<comment>Ce boolean sera utilisé pour signaler au processus s'il doit continuer ou s'arreter.</comment>privateboolean stopThread = false;publicvoid run()boolean fin = false;while( !fin )try<comment>traitement</comment>synchronized(this)Thead.yield();<comment>lecture du boolean</comment>fin = this.stopThread; catch( InterruptedException e )publicsynchronizedvoid stop()this.stopThread = true;
2<sup>ème</sup> squelette standard
La solution précédente est adaptée aux threads qui effectuent régulièrement le même traitement. Si le traitement est très long, il peut être nécessaire de tester la requête de fin en cours de traitement. Le plus simple est alors de lever une exception en cours de traitement.
privateboolean stopThread = false;publicsynchronizedvoid testFin() throws InterruptedExceptionif( stopThread )thrownew InterruptedException();publicvoid run()try<comment>traitement avec un appel régulier à testFin();</comment> catch( InterruptedException e )publicsynchronizedvoid stop()this.stopThread = true;
On peut utiliser la classe <javaClass class="java.lang.Thread" /> ou implémenter l'interface <javaInterface name_interface="java.lang.Runnable" />, mais suivant les cas de figure cela représente beaucoup de code et de contraintes. En effet, les instructions qui affectent ou dépendent d'un composant graphique Swing doivent être effectuées par le processus d'évènement (the event-dispatching thread). Par conséquent si l'on utilise la classe Thread ou l'interface Runnable il est nécessaire d'utiliser les méthodes : <javaMethode class="javax.swing.SwingUtilities" methode="invokeLater(java.lang.Runnable)" /> ou <javaMethode class="javax.swing.SwingUtilities" methode="invokeAndWait(java.lang.Runnable)" /> de la classe <javaClass class="javax.swing.SwingUtilities" />.
La classe Timer :
La classe <javaClass class="javax.swing.Timer" /> remplace avantageusement l'utilisation directe de thread. Elle génère un évènement à intervalles réguliers (à la milli-seconde). C'est le "event-dispatching thread" qui exécute l'évènement, donc on peut directement modifier des objets graphiques.
Méthodes importantes :
le constructeur de <javaClass class="javax.swing.Timer" /> :
public Timer (int delay, ActionListener listener); <comment>delay = l'intervale de temps entre chaque évènement.listener = l'objetécouteur de ces evènements.</comment>
méthode permettant de lancer le processus :
publicvoid start();
méthode permettant de stopper le processus :
publicvoid stop();
Note :
Cette méthode est à utiliser uniquement si le traitement à faire est court en temps d'exécution sinon on aura une interface non réactive pendant le traitement ....
Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduit en français ici.
Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement.
