public  class Thermostat {

    private Object key =  new Object() ;

    // méthode statique synchronisée, le paramètre de synchronisation est
    // l'objet Thermostat.class
    public  static  synchronized  boolean getNombreThermostats() {
      
       // corps de la méthode
   }

    // méthode non statique synchronisée, le paramètre de synchronisation est
    // l'objet this
    public  synchronized  boolean plusChaud() {
      
       // corps de la méthode
   } 
   
    public  boolean plusFroid() {
      
       // synchronization sur l'objet key
       // on peut aussi synchroniser sur l'objet this
       synchronized(key) {
      
          // bloc synchronisé
      }
   }
}

public  class Verre {

    // permet de savoir si le verre est vide ou pas
    private  boolean plein = false ;
   
    // un verre a besoin d'une carafe pour se remplir
    private Carafe carafe ;

    // on ne peut se remplir que si la carafe est pleine
    public  synchronized  void remplis() {
       if (carafe.isPlein()) {
         plein = true ;
         carafe.setPlein(false) ;
      }
   }

    // et l'on ne peut se vider que si la carafe est vide
    public  synchronized  void vide() {
       if (!carafe.isPlein()) {
         plein = false ;
         carafe.setPlein(true) ;
      }
   }
   
    // permet au monde extérieur de sa voir
    // si nous sommes plein ou vide
    public  synchronized  boolean isPlein() {
       return  this.plein ;
   }

    // reste des getters non synchronisé
    public  void setPlein(boolean plein) {
       this.plein = plein ;
   }
	
    public Carafe getCarafe() {
       return carafe ;
   }
}

public  class Carafe {

    // permet de savoir si la carafe est vide ou pas
    private  boolean plein = false ;
   
    // un verre a besoin d'un verre pour se vider
    private Verre verre ;

    // on ne peut se remplir que si le verre est plein
    public  synchronized  void remplis() {
       if (verre.isPlein()) {
         plein = true ;
         verre.setPlein(false) ;
      }
   }

    // et l'on ne peut se vider que si le verre est vide
    public  synchronized  void vide() {
       if (!verre.isPlein()) {
         plein = false ;
         verre.setPlein(true) ;
      }
   }
   
    // permet au monde extérieur de sa voir
    // si nous sommes plein ou vide
    public  synchronized  boolean isPlein() {
       return  this.plein ;
   }

    // reste des getters non synchronisé
    public  void setPlein(boolean plein) {
       this.plein = plein ;
   }
	
    public Verre getVerre() {
       return verre ;
   }
}

// dans une méthode main
 // initialisation d'une carafe et d'un verre, associés l'un à l'autre
 final Carafe carafe =  new Carafe() ;
 final Verre verre =  new Verre() ;
carafe.setVerre(verre) ;
verre.setCarafe(carafe) ;

 // création d'une instance de Runnable qui remplit et vide la carafe
 // dans le verre
 // on peut augmenter le nombre de cycles dans la boucle for
Runnable carafeApp =  new Runnable() {
	
    public  void run() {

       for (int i =  0 ; i <  20 ; i++) {
         carafe.remplis() ;
         carafe.vide() ;
      }
   }
} ;

 // création d'une instance de Runnable qui remplit et vide le verre
 // dans la carafe
 // on peut augmenter le nombre de cycles dans la boucle for
Runnable verreApp =  new Runnable() {

    public  void run() {

       for (int i =  0 ; i <  20 ; i++) {
         verre.remplis() ;
         verre.vide() ;
      }
   }
} ;

 // création des threads
Thread [] carafeApps =  new Thread [5] ;
Thread [] verreApps =  new Thread [5] ;

 // creation des threads pour le vidage de la carafe
 // et du verre
 for (int i =  0 ; i < carafeApps.length ; i++) {
   carafeApps[i] =  new Thread(carafeApp) ;
   verreApps[i] =  new Thread(verreApp) ;
}

 // lancement des threads
 for (int i =  0 ; i < carafeApps.length ; i++) {
   carafeApps[i].start() ;
   verreApps[i].start() ;
}

 // attente de la fin de l'exécution des threads
 for (int i =  0 ; i < carafeApps.length ; i++) {
   carafeApps[i].join() ;
   verreApps[i].join() ;
}