Cours CNAM par J. Laforgue

Exemple25_Thread

Retour

Télécharger

Exemple de création de deux thread qui affichent un caractère different en parallele et une IHM qui permet de gerer l'execution des deux threads

README.txt
Exemple25.java

// Exemple de création de deux thread qui affichent un caractère different en parallele et une IHM qui permet de gerer l'execution des deux threads
//
import fr.cnam.ihm.*;

public class Exemple25 implements FormulaireInt
{
    private Formulaire form;
    private MonThread t1;
    private MonThread t2;
    private MonThread t3;

public Exemple25()
    {
        form = new Formulaire("Thread",
                              this,
                              false,
                              600,600,true);
        
        form.addButton("SUSP1","Suspendre le thread 1",-1,-1,500);
        form.addButton("SUSP2","Suspendre le thread 2",-1,-1,500);
        form.addButton("REPR1","Reprendre le thread 1",-1,-1,500);
        form.addButton("REPR2","Reprendre le thread 2",-1,-1,500);
        int x = form.getXCour();
        int y = form.getYCour();
        form.addText("TIMESLEEP","Time sleep",true,""+MonThread.timeSleep,
                     x,y,100,5,40);
        form.addButton("VALIDER_TIMESLEEP","Valider",
                       x+150,y,120);
        form.addButton("EXCLUSIF","Bascule exclusif",x,-1,300);
        form.addButton("STOP1","Stopper le thread 1",-1,-1,500);
        form.addButton("STOP2","Stopper le thread 2",-1,-1,500);
        x = form.getXCour();
        y = form.getYCour();
        form.addText("DATA","Val commun thread",true,MonThread.paramGen1,
                     x,y,150,5,30);
        form.addButton("VALIDER_DATA","Valider",
                       x+170,y,120);

form.afficher();

// Creation des deux threads
        //
        t1 = new MonThread('X');
        t2 = new MonThread('-');
        t3 = new MonThread('/');

// Demarrage des deux threads
        //
        t1.start();
        t2.start();
        t3.start();

}

public static void main(String[] args)
    {
        Exemple25 exemple = new Exemple25();
    }

public void submit(Formulaire f,String nomBouton)
    {
        if (nomBouton.equals("SUSP1"))
            t1.suspendre();

if (nomBouton.equals("SUSP2"))
            t2.suspendre();

if (nomBouton.equals("REPR1"))
            t1.reprendre();

if (nomBouton.equals("REPR2"))
            t2.reprendre();
        
        if (nomBouton.equals("VALIDER_TIMESLEEP"))
            {
                int value = Integer.parseInt(f.getValeurChamp("TIMESLEEP"));
                MonThread.setTimeSleep(value);
            }

if (nomBouton.equals("EXCLUSIF"))
            MonThread.exclusion = ! MonThread.exclusion;

if (nomBouton.equals("STOP1"))
             t1.stopper();

if (nomBouton.equals("STOP2"))
             t2.stopper();

if (nomBouton.equals("VALIDER_DATA"))
            {
                MonThread.paramGen1 = f.getValeurChamp("DATA");
            }

}
}

MonThread.java

import java.util.Random;

// Exemple type d'un thread dont le traitement est cyclique
//
public class MonThread extends Thread
{
    // Exclusion de l'itération 
    final static Integer verrou = new Integer(0);  
    public static boolean exclusion = false;

// Un paramettre commun à tous les threads
    static public String paramGen1 = "";

// Temps d'arret du thread
    static public int timeSleep = 1000;

// Parametre du thread (propre à chaque thread)
    char   param1;

// Arret du thread (propre à chaque thread)
    boolean stop;

// Pour suspendre le thread (propre à chaque thread)
    boolean suspend;

// Constructeur du thread
    //
    public MonThread(char param1)
    {
        this.stop    = false;
        this.suspend = false;
        
        this.param1 = param1;
    }
    
    // Traitement du Thread : la méthode run
    //  
    public void run()
    {
        while(! this.stop)
            {
                // La méthode run ne peut pas retourner d'exception
                try{

if (!exclusion) traitement1(20);
                    else traitement2(20);

// Toujours laisser du temps au sequenceur
                    try{
                        Thread.sleep(timeSleep);
                    }catch(Exception ex){};

// Pour suspendre le thread
                    synchronized(this)
                        {
                            while (suspend && !stop) 
                                {
                                        wait();
                                }
                        }
                }
                catch(Exception ex)
                    {
                        //Erreur sur l'itération du traitement
                    }
            }
    }

// Ce traitement n'est pas synchrone
    //
    private void traitement1(int nb)
    {
        for(int i=0;i<nb;i++)
            {
                System.out.print(""+param1+paramGen1);
                System.out.flush();
                try{Thread.sleep(30);}catch(Exception ex){};
            }
        System.out.println();
    }

// Ce traitement est synchrone
    //
    private void traitement2(int nb)
    {
        synchronized(verrou)
            {
                for(int i=0;i<nb;i++)
                    {
                        System.out.print(""+param1+paramGen1);
                        System.out.flush();
                        try{Thread.sleep(40);}catch(Exception ex){};
                    }
                System.out.println();
            }
    }

// Stoppe le thread qui s'arrête
    //
    public void stopper()
    {
        this.stop=true;
    }

// Suspendre le thread
    //   (la méthode run se met en wait sur le thread)
    //
    public void suspendre()
    {
        this.suspend=true;
    }

// Reprendre le thread
    //   
    public void reprendre()
    {
        synchronized(this)
            {
                notify();  // libère le wait
            }
        this.suspend=false;
    }

// Tempo entre chaque itération de la méthode thread
    //
    synchronized static void setTimeSleep(int timeSleep_p)
    {
        timeSleep = timeSleep_p;
    }
}

Terminal.java

import java.io.*;

public class Terminal{    
    static BufferedReader in =
        new BufferedReader(new InputStreamReader(System.in));

public static String lireString() // Lire un String
    {
        String tmp="";
        char C='\0';
        try {
            tmp = in.readLine();
        }
        catch (IOException e)
            {
                exceptionHandler(e);
            }
        return tmp;
    } // fin de lireString()
    public static int lireInt()  // Lire un entier
    {
        int x=0;
        try {
            x=Integer.parseInt(lireString());
        }
        catch (NumberFormatException e) {
            exceptionHandler(e);
        }    
        return x ;
    }
    public static boolean lireBoolean()  // Lire un entier
    {
        boolean b = true;
        try {
            b = Boolean.valueOf(lireString()).booleanValue();
        }
        catch (NumberFormatException e) {
            exceptionHandler(e);
        }    
        return b;
    }
    public  static double lireDouble()  // Lire un double
    {
        double x=0.0;
        try {
            x=Double.valueOf(lireString()).doubleValue();
        }
        catch (NumberFormatException e) {
            exceptionHandler(e);
        }    
        return x ;
    }
    public  static char lireChar()  // Lire un caractere
    {
        String tmp=lireString();
        if (tmp.length()==0)
            return '\n';
        else 
            {
                return tmp.charAt(0);
            }
    }
    public static void ecrireString(String s){ // Afficher un String
        try{
            System.out.print(s);
        } catch (Exception ex){
            exceptionHandler(ex);
        }
    }
    public static void ecrireStringln(String s) // Afficher un String
    {
        ecrireString(s);
        sautDeLigne();
    } // fin de ecrireStringln()
    public static void ecrireInt(int i)  // Afficher un entier
    {
        ecrireString(""+i);
    }
    public static void ecrireIntln(int i)  // Afficher un entier
    {
        ecrireString(""+i);
        sautDeLigne();
    }
    public static void ecrireBoolean(boolean b){
        ecrireString(""+b);
    }
    public static void ecrireBooleanln(boolean b){
        ecrireString(""+b);
        sautDeLigne();
    }
    public  static void ecrireDouble(double d)  // Afficher un double
    {
        ecrireString(""+d);
    }
    public  static void ecrireDoubleln(double d)  // Afficher un double
    {
        ecrireDouble(d);
        sautDeLigne();
    }
    public  static void ecrireChar(char c)  // Afficher un caractere
    {
        ecrireString(""+c);
    }  
    public  static void ecrireCharln(char c)  // Afficher un caractere
    {
        ecrireChar(c);
        sautDeLigne();
    }
    public static void sautDeLigne(){
        try{
            System.out.println();
        }catch(Exception ex){
            exceptionHandler(ex);
        }
    }
    protected static void exceptionHandler(Exception ex){
        TerminalException err = new TerminalException(ex);
        throw err;
    }
    public static void ecrireException(Throwable ex){
        ecrireString(ex.toString());
        ex.printStackTrace(System.err);
    }
}  
class TerminalException extends RuntimeException{
    Exception ex;
    TerminalException(Exception e){
        ex = e;
    }
}

compil.bat
run.bat

Cours d'Informatique par Jacques LAFORGUE

Retour

Télécharger

Cours d'Informatique
par Jacques LAFORGUE