Méthode Wait() en Java

Dans cet article, nous examinerons la méthode wait() pour contrôler le thread et les méthodes notify() / notifyAll() . Ces méthodes sont définies dans la classe de base java.lang.Object et, par conséquent, les mécanismes d'héritage de Java fournissent ces méthodes à absolument toutes les classes. Autrement dit, lorsque vous créez votre propre classe et ses objets, vous pouvez toujours appeler ces méthodes.

Comment fonctionnent les méthodes wait() et notify()/notifyAll()?

• attendre() . en bref, cette méthode libère le moniteur et met le thread appelant dans un état d'attente jusqu'à ce qu'un autre thread appelle la méthode notify() / notifyAll() ;
• notifier() . Continue le travail d'un thread dont la méthode wait() a été précédemment appelée ;
• La méthode notifyAll() reprend tous les threads dont la méthode wait() a été précédemment appelée.

Examinons maintenant de plus près la méthode wait() . La classe Object contient trois options pour cette méthode :

• public final native void wait(long timeoutMillis) lance InterruptedException ; Cela fait attendre le thread actuel jusqu'à ce qu'il soit réveillé. Habituellement, cela se produit en étant averti ou interrompu, ou jusqu'à ce qu'un certain temps réel se soit écoulé.

• public final void wait() lève InterruptedException . Ce n'est pas un hasard si nous avons écrit une méthode sans paramètres comme la seconde. En fait, si vous regardez son code, il fait référence à la première variante de la méthode, il a juste l'argument 0L.

• public final wait​(long timeout, int nanos) . Fait attendre le thread actuel jusqu'à ce qu'il soit réveillé, généralement en étant notifié ou interrompu, ou jusqu'à ce qu'un certain temps réel se soit écoulé.

La méthode wait() est destinée à suspendre le thread appelant. Qu'est-ce que ça veut dire? Ces méthodes appartiennent à la classe. En fonction de la classe, vous créez un objet. Les objets existent dans certains threads. C'est-à-dire que des objets sont créés dans certains threads. Dans le thread dans lequel cet objet fonctionne, si vous y appelez wait() , cela conduira au fait que ce thread s'arrêtera. L'objet lui-même agit comme une sorte de moniteur. Qu'est-ce que c'est? Il est clair que vous pouvez créer différents objets et tous contiendront le wait ()méthode. Il existe une compréhension de l'objet qui a provoqué l'arrêt d'un thread particulier. Le thread s'arrête et attendra tant qu'il est écrit dans le paramètre. Et puis ça va commencer. Ce fil ne peut pas démarrer lui-même. Pour reprendre le travail, il existe des méthodes notify et notifyAll. Un appel à notify() ou notifyAll() doit lire un autre thread. Avec wait() , vous pouvez arrêter plusieurs threads et démarrer tous les threads avec notifyAll() . Si plusieurs threads ont été arrêtés et que notify() a été appelé, il est impossible de dire exactement quel thread reprendra cette méthode. S'il n'y a pas de threads en attente sur la méthode wait() , alors rien ne se passe lorsque notify() ounotifyAll() est appelée. Un thread peut appeler les méthodes wait() ou notify() sur un objet particulier uniquement s'il a actuellement un verrou sur cet objet. wait() , notify() et notifyAll() ne doivent être appelés qu'à partir du code synchronisé.

Exemple de méthode Wait()

Nous avons ici l'un des exemples les plus populaires qui illustre le fonctionnement de la méthode. Disons que nous avons un magasin, un producteur et un consommateur. Le fabricant transfère certains produits de production au magasin, après quoi le consommateur peut les emporter. Si le fabricant doit produire 8 biens, respectivement, le consommateur doit tous les acheter. Mais en même temps, pas plus de 6 articles peuvent être dans l'entrepôt en même temps. Pour résoudre ce problème, nous utilisons les méthodes wait() et notify(). Définissons trois classes : Market , Manufacturer et Client . La méthode Manufacturer in the run() ajoute 8 produits à l' objet Market en utilisant sonméthode put() . Le client de la méthode run() dans une boucle appelle la méthode get de l' objet Market pour obtenir ces produits. Les méthodes put et get de la classe Market sont synchronisées. Pour suivre la présence de marchandises dans la classe Market , nous vérifions la valeur de la variable item. La méthode get() pour obtenir un produit ne devrait se déclencher que s'il y a au moins un produit. Par conséquent, dans la méthode get, nous vérifions si le produit est manquant. Si l'élément n'est pas disponible, la méthode wait() est appelée. Cette méthode libère le moniteur de l'objet Market et bloque la méthode get jusqu'à ce que le notify()méthode est appelée sur le même moniteur. Lorsqu'un élément est ajouté dans la méthode put() et que notify() est appelé, la méthode get() obtient le moniteur. Après cela, notre client reçoit un article. Pour ce faire, un message s'affiche, et la valeur de l'item est décrémentée. Enfin, l' appel de la méthode notify() signale à la méthode put() de continuer. Dans la méthode put() , une logique similaire fonctionne, seulement maintenant la méthode put() devrait fonctionner s'il n'y a pas plus de 6 produits dans le Market .

class Market {

   private int item = 0;

   public synchronized void get() {
       //here we use wait() method
       while (item < 1) {
           try {
               wait();
           }
           catch (InterruptedException e) {
           }
       }
       item--;
       System.out.println("A client has bought 1 item...");
       System.out.println("Items quantity in Market warehouse... " + item);
       notify();
   }

   public synchronized void put() {
       //here we use wait() method when the Warehouse is full
       while (item >= 6) {
           try {
               wait();
           }
           catch (InterruptedException e) {
           }
       }
       item ++;
       System.out.println("Manufacturer has added 1 more item...");
       System.out.println("Now there are " + item + " items in Warehouse" );
       notify();
   }
}

class Manufacturer implements Runnable {

   Market market;

   Manufacturer(Market market) {
       this.market = market;
   }


   public void run() {
       for (int i = 0; i < 8; i++) {
           market.put();
       }
   }
}

class Client implements Runnable {

   Market market;
   Client(Market market) {
       this.market = market;
   }
   public void run() {
       for (int i = 0; i < 8; i++) {
           market.get();
       }
   }
}
//wait() method test class
public class WaitTest {
   public static void main(String[] args) {

       Market market = new Market();
       Manufacturer manufacturer = new Manufacturer(market);
       Client client = new Client(market);
       new Thread(manufacturer).start();
       new Thread(client).start();
   }
}

Ici, en utilisant wait() dans la méthode get() , nous attendons que le fabricant ajoute un nouvel élément. Et après avoir ajouté, nous appelons notify() , comme pour dire qu'une place est devenue libre sur le Warehouse, et vous pouvez en ajouter d'autres. Dans la méthode put() , en utilisant wait() , nous attendons la libération d'espace sur le Warehouse . Une fois l'espace libre, nous ajoutons l'élément, notify() démarre le fil et le client peut récupérer l'élément. Voici la sortie de notre programme: