Utiliser l'interface Runnable

Utiliser l'interface `Runnable`

l'interface java.lang.Runnable déclare uniquement la méthode :
    public abstract void run.
La classe Thread possède un constructeur recevant un argument de type RunnableSupposons qu'un objet r soit de type Runnable (c'est-à-dire une instance d'une classe qui implémente l'interface Runnable). Si on écrit :
    Thread t = new Thread(r);
on crée un nouveau thread qu'on peut alors faire démarrer par l'instruction :

pour y exécuter la méthode run de t qui appelle alors la méthode run de r (le Runnable transmis par le constructeur).
Un avantage est que la classe peut alors étendre une autre classe au choix ; en effet, java ne permettant pas l'héritage multiple, si on définit une classe qui étend la classe Thread, cela interdit d'étendre une autre classe.

Le programme ci-dessous fait la même chose que l'exemple donné dans la page précédente, sauf les quelques écritures sur des valeurs de priorité..

class RepetiteurR implements Runnable
{
  String chaine;

  RepetiteurR(String chaine)
    {
      this.chaine = chaine;
    }
  
  public void run()
    {
       System.out.println(chaine);
       Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
       System.out.println(chaine);
    }
}

class EcrivainR 
{
  public static void main(String[] argv)
    {
      new Thread(new RepetiteurR("soleil")).start();
      new Thread(new RepetiteurR("neige")).start();
      new Thread(new RepetiteurR("ski")).start();
      System.out.println("A la montagne");
    } 
}

Vous pouvez accéder à l'exemple.

Runnable : la classe java.lang.Runnable contient uniquement la déclaration de la méthode
public abstract void run()

Thread.currentThread() : la méthode currentThread() est une méthode statique qui retourne une référence vers le processus qui est en train de s'exécuter.

new Thread(new RepetiteurR("soleil")).start(); : la classe Thread admet un constructeur qui prend en argument une instance de Runnable. Par cette instruction, on construit une instance de la classe RepetiteurR, qui est aussi une instance de Runnable puisque la classe RepetiteurR implémente cette interface. On construit une nouvelle instance de la classe Thread ayant pour paramètre notre instance de RepetiteurR : cela implique que la méthode run exécutée par le thread construit sera celle de l'instance de RepetiteurR et s'appliquera aux données de cette même instance. On fait alors démarrer la thread avec la méthode start de la classe Thread.
On aurait pu aussi procéder de manière moins condensée en décomposant ainsi :

   RepetiteurR monRepetiteur;
   monRepetiteur = new RepetiteurR("soleil");
   Thread monThread;
   monThread = new Thread(monRepetiteur);
   monThread.start();