L'interface Runnable

Les applets peuvent utiliser des processus en implémentant l'interface Runnable qui demande une méthode run. Le processus doit être associé à l'applet par son constructeur, sa méthode start appelle alors la méthode run de l'applet.

Squelette d'applet implémentant l'interface Runnable

L'applet gère un processus à travers une variable de type Thread. Sa méthode start, appelée juste après init, crée le processus et le démarre, ce qui provoque l'exécution de la méthode run. Celle-ci est formée d'une boucle dans laquelle se fait le travail du processus, avec à chaque tour un arrêt (méthode wait) permettant au processus principal de l'applet de s'exécuter pour la gestion des évènements (affichage, souris, boutons, etc...). Une variable speed permet de gérer le temps d'arrêt qui est exprimé en millièmes de secondes. Enfin nous utilisons la méthode stop de l'applet, qui est appelée lors de la fermeture de la page html, pour stopper le processus.

        import java.awt.*;
        import java.applet.*;

        public class MaClasse extends Applet 
         implements Runnable {

         private Thread processus=null;
         int speed=20;

         public void init() {
         }
 
         public void start() {
          if (processus==null) {
           processus=new Thread(this);
           processus.start();
          }
         }

         public void stop() {
          processus.stop();
          processus=null;
         }

         public void run() {
          while (processus!=null) {
           repaint();
           //modifications du dessin
           try {
            processus.sleep(speed);
           } catch (InterruptedException e){}
          }
          processus=null;
         }

        }

Création d'un chronomètre

A titre d'exemple, créons une applet qui affiche un chronomètre en utilisant le modèle précédent.

Comme le chronomètre affiche les dixièmes de secondes, la variable speed est fixée à 100.

Une variable ds compte les dixièmes de secondes. Le travail du processus se limite donc à incrémenter cette variable et à réafficher le chronomètre.

        import java.awt.*;
        import java.applet.*;

        public class Chrono1 extends Applet 
         implements Runnable {
 
         private Thread chronometre; 
         int speed=100;
         private int ds=0;  //dixième de seconde
 
         public void init() {
          setBackground(Color.white);
          setForeground(Color.blue);
          setFont(new Font("SansSerif",Font.BOLD, getSize().height));
         }
 
         public void start () {
          // Au début de l'applet, création et démarrage du chronomètre
          if (chronometre==null) {
           chronometre=new Thread(this);
           chronometre.start();
          } 
         }

         public void run () {
          while (chronometre!=null) {
           repaint ();
           ds++;
           try {
            chronometre.sleep(speed);
           } catch (InterruptedException e) {}
          } 
         }

         public void stop () {
          // A la fin de l'applet, arrêt du chronometre
          chronometre.stop();
          chronometre=null;
         }

         public void paint (Graphics g) {
          // Dessine le temps écoulé sous forme de h:mm:ss:d  
          String S=ds/36000 +":"+(ds/6000)%6+(ds/600)%10
            +":"+(ds/100)%6+(ds/10)%10+ ":" + ds%10;
          //affichage centré  
          FontMetrics fm=g.getFontMetrics();
          int largeur=fm.stringWidth(S);
          int hauteur=fm.getHeight();
          int x=(getSize().width-largeur)/2;
          int y=(getSize().height-hauteur)/2;  
          g.drawString(S, x, y+hauteur-fm.getDescent());
         }
        }

En utilisant le modèle fourni précédemment, il nous a suffi d'écrire les méthodes init (choix des couleurs) et paint (affichage), puis de compléter la méthode run pour incrémenter le nombre de secondes.