Programmation des Threads en Java, première partie

19/07/2004

Par Valère VIANDIER
 

Ce tutorial explique l'utilisation des Threads en Java

• Faire des traitements en tâche de fond, c'est le cas de la coloration syntaxique des éditeurs.
• Exécuter plusieurs instances d'un même code pour accélérer le traitement, pour de long traitements n'utilisant pas les mêmes ressources.
• S'adresser de manière personnelle à plusieurs clients simultanément comme les serveurs HTTP ou les Chat.
• Résoudre certaines problématiques liées au mode de fonctionnement de Swing.

Signature de la méthode run
public void run() ;

Principaux constructeurs
public Thread();
public Thread(Runnable runnable);

Lancement d'un Thread
MonThread t = new MonThread() ;
t.start();

Exemple
public class MonThread extends Thread {
  public void run() {
    // faire quelque chose
  }
}

Exemple avec passage de paramètre
public class MonThread extends Thread {
  private String str;
  
  public MonThread(String str) {
    this.str = str;
  }
  public void run() {
    // faire quelque chose avec str
  }
}

Source de du Thread
package tutorialthread.example01;

public class UnThread extends Thread{
  public void run() {
    long start = System.currentTimeMillis();
    // boucle tant que la durée de vie du Thread est < à 5 secondes
    while( System.currentTimeMillis() < ( start + (1000 * 5))) {
      // traitement
      System.out.println("Ligne affichée par le thread");
      try {
        // pause
        Thread.sleep(500);
      }
      catch (InterruptedException ex) {}
    }
  }	
}

Source de la classe de test
package tutorialthread.example01;

public class Main {
  public Main() {
    // création d'une instance du Thread
    UnThread thread = new UnThread();
    // Activation du Thread
    thread.start();
    // tant que le thread est en vie...
    while( thread.isAlive() ) {
      // faire un traitement...
      System.out.println("Ligne affichée par le main");
      try {
        // et faire une pause
        Thread.sleep(800);
      }
      catch (InterruptedException ex) {}
    }
  }
  
  public static void main(String[] args) {
    new Main();
  }

}

Threads désynchronisés
/*
 * Created on 8 juil. 2004
 *
 */
package tutorialthread.examples.sync;

import java.util.Random;

/**
 * @author Valère VIANDIER
 *
 */
public class VaseComuniquant {
    private static final int QUANTITE_INITIALE = 200;
    private static final int NB_THREAD_MAX = 2;
    
    private static int iteration = 0;
    
    private int[] vase = {QUANTITE_INITIALE / 2,QUANTITE_INITIALE / 2};

    public VaseComuniquant() {
        for( int i = 0; i < NB_THREAD_MAX; i++)
            new ThreadTransfert().start();
    }
    public static void main(String[] args) {
        new VaseComuniquant();
    }
    
    public int transfert(int qte) {
        // Ne pas enlever les System.out de ce test !
        System.out.print("-("+qte+") dans le vase 1 ");
        vase[0] -= qte;
        System.out.println("+("+qte+") dans le vase 2");
        vase[1] += qte;
        iteration++;
        if( iteration % 1000 == 0)
            System.out.println("" + iteration + " itérations.");
        return vase[0]+vase[1];
    }
    
    public class ThreadTransfert extends Thread {
        Random r = new Random();
        int quantite;
        public void run() {
            while( !isInterrupted()) {
                quantite = r.nextInt(11)-6;
                vase[0] -= quantite;
                vase[1] += quantite;
                if( transfert(quantite) != QUANTITE_INITIALE) {
                    System.err.println("Quantité totale invalide à l'itération " + iteration);
                    System.exit(-1);
                }
                
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {}
            }
        }
        
    }
}

public synchronized int transfert(int qte) {
  ...
}

• Les événements doivent être dépilés dans le même ordre.
• Les événements ne doivent pas êtres dispatchés en même temps.

Voici le code de notre traitement
/*
 * Created on 7 juil. 2004
 *
 */
package tutorialthread.examples.swing;

import javax.swing.JProgressBar;

/**
 * @author Valère VIANDIER
 *
 */
public class LongAction {

    public void traitementLong(JProgressBar pBar) {
        // initialisation de la progressBar au début du traitement
        pBar.setMinimum(0);
        pBar.setMaximum(99);
        pBar.setValue(0);
        
        // Traitement
        for( int i = 0; i < 100; i++ ) {
            System.out.print(".");
            pBar.setValue(i);
            try {
                // Pause pour simuler un traitement
                Thread.sleep(100);
            } catch (InterruptedException e) {}
        }
        System.out.println("") ;
    }
}

Code de la classe de test
/*
 * Created on 7 juil. 2004
 *
 */
package tutorialthread.examples.swing;

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;

/**
 * @author Valère VIANDIER
 *
 */
public class TestTraitementLong extends JFrame {
  JProgressBar jBar = new JProgressBar();
  GridLayout layout = new GridLayout(2,1);
  JButton btnAction = new JButton("Lancer le traitement");

  public TestTraitementLong() {
    // Construction de la fenêtre de test
    Container contentPane = getContentPane();
    contentPane.setLayout(layout);
    contentPane.add(jBar);
    contentPane.add(btnAction);
    setTitle("Test de progressBar");
    // Ajout du listener du bouton
    btnAction.addActionListener(
      new ActionListener() {
        public void actionPerformed(ActionEvent e) {
          // Instanciation et lancement du traitement
          LongAction action = new LongAction();
          action.traitementLong(jBar);
        }
      }
    );
        
    // Affichage de la fenêtre
    pack();
    setVisible(true);
        
  }
  
  public static void main(String[] args) {
    new TestTraitementLong();
  }
}

• La barre de progression n'avance pas.
• La console affiche bien les points ce qui indique que le traitement s'effectue.
• Si vous agrandissez la fenêtre pendant le traitement, celle-ci ne se rafraîchie pas.
• A la fin du traitement, la barre de progression affiche 100% et la fenêtre se redessine correctement.

Code du listener
btnAction.addActionListener(
  new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      // création d'un Thread d'exécution
      Thread t = new Thread() {
        public void run() {
          // Instanciation et lancement du traitement
          LongAction action = new LongAction();
          action.traitementLong(jBar);
        }
      };
      t.start();
    }
  }
);