Exemple de thread avec Java—la classe TiPoints

interface Vautour {
  public void signalFin ();
}

public class TiPoints implements Vautour {
  //
  // Classe interne, thread lisant une touche et
  // signalant à un Vautour que la touche a été lue
  //
  private class LireUneTouche extends Thread {
    private Vautour m_Observateur;
    public LireUneTouche (Vautour observateur) {
      m_Observateur = observateur;
    }
    public void run () {
      try {
        System.in.read ();
      } catch (java.io.IOException ioe) {
      }
      m_Observateur.signalFin ();
    }
  }
  //
  // Le code de TiPoints à proprement dit
  //
  private boolean m_Décès;
  public void signalFin () {
    m_Décès = true;
  }
  public TiPoints () {
    m_Décès = false;
  }
  public boolean estDécédé () {
    return m_Décès;
  }
  public void agir () {
    LireUneTouche lut = new LireUneTouche (this);
    lut.start ();
    while (!estDécédé ()) {
      System.out.print (".");
      try {
        Thread.sleep (1000);
      } catch (InterruptedException ie) {
      }
    }
  }
  public static void main(String[] args) {
    TiPoints tp = new TiPoints ();
    tp.agir ();
  }
}

Tel que vu en classe, un thread Java est une classe dérivant de thread et exposant une méthode publique de type void nommée run(). Il y a des variantes à cette stratégie, explorées dans les notes de cours et qui impliquent l'interface Runnable, mais nous limiterons notre regard à l'essentiel.

Dans l'exemple proposé à droite, que vous pouvez déposer dans le fichier TiPoints.java, puis compiler et exécuter :

• l'interface Vautour exige de celles et ceux qui l'implémentent qu'il implémentent aussi la méthode publique de type void nommée signalFin();
• la classe TiPoints est un cas particulier de Vautour. Lorsqu'un TiPoints est instancié, il est vivant, mais si sa méthode signalFin() est invoquée, il décède gracieusement dans la seconde qui suit;
• lorsqu'un TiPoints agit (par sa méthode agir(), disons), il crée puis lance un thread (créant et démarrant une instance de LireUneTouche, une petite classe interne), pour ensuite afficher un petit point à la console une fois par seconde;
• chaque instance de LireUneTouche a pour mandat d'informer un Vautour (par exemple : un TiPoints) qu'une touche a été pressée en invoquant sa méthode signalFin(). C'est un cas très simplifié du schéma de conception Observateur, très utile dans des systèems tels que les applications Internet.

Je vous invite à essayer le tout et à poser des questions s'il y a lieu.