Cours CNAM par J. Laforgue

Exemple26_Synchronisation

Retour

Télécharger

Demonstration de l'utilisation des methodes wait et notify de Java
Deux programmes : run (exécution de Exemple26)
runSimple (un cas simple de synchronisation)

Exemple26.java

//Demonstration de l'utilisation des methodes wait et notify de Java
// Deux programmes : run (exécution de Exemple26)
//                   runSimple (un cas simple de synchronisation)
//
import java.util.*;

public class Exemple26 
{
    public static void main(String... args)
    {
        // Un tableau partagé entre les 3 threads
        ListeTab l = new ListeTab();
        
        // Un thread qui ajoute un élément dans le tableau
        AjouterThread   t1 = new AjouterThread(l);

// Un thread qui veut accéder au premier élément du tableau
        PremierThread   t2 = new PremierThread(l);

// Un thread qui vide le tableau puis ajoute un élément
        ViderThread t3 = new ViderThread(l);
        
        t2.start();  // GetPremier
        
        // 2 secnodes d'attente
        try{Thread.sleep(2000);}catch(Exception ex){};
        t1.start();  // Ajouter
        t3.start();  // Vider puis ajouter
        // Le vidage se fait de suite après l'ajout
    }
}

// La ressource partagée : le tableau
//
class ListeTab
{
    private String[] tab;
    private int      index;

public ListeTab()
    {
        tab = new String[50];
        index = 0;
    }

synchronized void ajouter(String s) 
    {
        // Ajout
        tab[index] = s;
        index++;

// Notification (au cas où un thread est en attente sur
        //   getPremierElementBloquant()
        //
        this.notifyAll();
        System.out.println("AJOUT>NotifyAll. Le getPremier et vider ne s'executent quand meme pas car ajouter toujours en cours"); 
        System.out.println("AJOUT> Taper une touche pour continuer...");
        Terminal.lireString();
    }

synchronized void vider() 
    {
        index=0;
        System.out.println("SUPPR>vider la liste"); 
    }

synchronized String getPremierElementBloquant() 
    {
        int cpt=0;
        //tant que la liste est vide
        while(index == 0) 
        {
            try {
                if(cpt>=1) System.out.println("======> BOUCLE "+cpt);
                //attente passive
                System.out.println("PREM>Wait");
                this.wait();  // attente et libère le verrou

System.out.println("PREM>Attente de 1 seconde");
                // Pour laisser le temps à vider de s'exécuter
                try{Thread.sleep(1000);}catch(Exception ex){};
                //
                cpt++;
            } catch(InterruptedException ie) {
                ie.printStackTrace();}
        }
        return tab[0];
    }
}

//================================================
class AjouterThread extends Thread
{
    private ListeTab liste;

public AjouterThread(ListeTab liste)
    {
        this.liste=liste;
    }

public void run()
    {
        System.out.println("AJOUT>Demarrage du thread d'ajout");
        liste.ajouter("TOTO");
    }
}

//================================================
class PremierThread extends Thread
{
    private ListeTab liste;

public PremierThread(ListeTab liste)
    {
        this.liste=liste;
    }

public void run()
    {
        System.out.println("PREM>Demarrage du thread de getPremier");
        String s = liste.getPremierElementBloquant();
        System.out.println("PREMIER ELEMENT: "+s);
    }
}

//================================================
class ViderThread extends Thread
{
    private ListeTab liste;

public ViderThread(ListeTab liste)
    {
        this.liste=liste;
    }

public void run()
    {
        System.out.println("SUPP>Demarrage du thread de vider");
        liste.vider();
        liste.ajouter("TATA");
    }
}

Simple.java

//Demonstration de l'utilisation des methodes wait et notify de Java
import java.util.*;

public class Simple
{
    
    public static void main(String... args)
    {
        Semaphore SEM = new Semaphore();

Simple1Thread   t1 = new Simple1Thread(SEM);
        Simple2Thread   t2 = new Simple2Thread(SEM);
        
        t1.start();
        t2.start();
    }
}

//================================================
class Semaphore
{
    synchronized public void notifier()
    {
        this.notify();
    }

synchronized public void attendre()
    {
        try{
            this.wait();
        }catch(Exception ex){ex.printStackTrace();}
    }
}
//================================================
class Simple1Thread extends Thread
{
    Semaphore SEM;
    public Simple1Thread(Semaphore sem) {SEM=sem;}
    public void run()
    {
        System.out.println("Simple1Thread>Demarrage du thread");
        System.out.println("Taper RC pour continuer...");
        Terminal.lireString();
        SEM.notifier();
    }
}

//================================================
class Simple2Thread extends Thread
{
    Semaphore SEM;
    public Simple2Thread(Semaphore sem) {SEM=sem;}
    public void run()
    {
        try{
            System.out.println("Simple2Thread>Demarrage du thread");
            SEM.attendre();
            System.out.println("XXXXXXXXXXXXXXXXXXXXX");
        }catch(Exception ex){ex.printStackTrace();}
    }
}

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
      runSimple.bat

Cours d'Informatique par Jacques LAFORGUE

Retour

Télécharger

Cours d'Informatique
par Jacques LAFORGUE