Wait() Methode in Java

In diesem Artikel betrachten wir die Methode wait() zur Steuerung des Threads und die Methoden notify() / notifyAll() . Diese Methoden sind in der Basisklasse java.lang.Object definiert und dementsprechend stellen die Vererbungsmechanismen in Java diese Methoden absolut allen Klassen zur Verfügung. Das heißt, wenn Sie Ihre eigene Klasse und ihre Objekte erstellen, können Sie diese Methoden jederzeit aufrufen.

Wie funktionieren die Methoden wait() und notify()/notifyAll()?

• warte() . Kurz gesagt, diese Methode gibt den Monitor frei und versetzt den aufrufenden Thread in einen Wartezustand, bis ein anderer Thread die Methode notify() / notifyAll() aufruft.
• notify() . Setzt die Arbeit eines Threads fort, dessen Methode wait() zuvor aufgerufen wurde;
• Die Methode notifyAll() setzt alle Threads fort, deren Methode wait() zuvor aufgerufen wurde.

Schauen wir uns nun die Methode wait() genauer an . Die Object- Klasse enthält drei Optionen für diese Methode:

• public final native void wait(long timeoutMillis) löst InterruptedException aus ; Dadurch wartet der aktuelle Thread, bis er aktiviert wird. Normalerweise geschieht dies durch Benachrichtigung oder Unterbrechung oder bis eine bestimmte Zeitspanne verstrichen ist.

• public final void wait() löst eine InterruptedException aus . Es ist kein Zufall, dass wir als zweite Methode eine Methode ohne Parameter geschrieben haben. Wenn Sie sich den Code ansehen, bezieht er sich tatsächlich auf die erste Variante der Methode und hat nur das Argument 0L.

• öffentliches letztes Warten (lange Zeitüberschreitung, int Nanos) . Bewirkt, dass der aktuelle Thread wartet, bis er aufgeweckt wird, typischerweise durch Benachrichtigung oder Unterbrechung, oder bis eine bestimmte Zeitspanne in Echtzeit verstrichen ist.

Die Methode wait() soll den aufrufenden Thread anhalten. Was bedeutet das? Diese Methoden gehören zur Klasse. Basierend auf der Klasse erstellen Sie ein Objekt. In einigen Threads sind Objekte vorhanden. Das heißt, in einigen Threads werden Objekte erstellt. Wenn Sie in dem Thread, in dem dieses Objekt arbeitet, wait() darin aufrufen, führt dies dazu, dass dieser Thread stoppt. Das Objekt selbst fungiert als eine Art Monitor. Was ist es? Es ist klar, dass Sie verschiedene Objekte erstellen können und alle von ihnen die Funktion wait() enthalten. Methode. Es besteht Verständnis dafür, welches Objekt den Stopp eines bestimmten Threads verursacht hat. Der Thread stoppt und wartet so lange, wie er in den Parameter geschrieben wird. Und dann geht es los. Dieser Thread kann sich nicht selbst starten. Um die Arbeit fortzusetzen, gibt es die Methoden notify und notifyAll. Ein Aufruf von notify() oder notifyAll() muss einen anderen Thread abspielen. Mit wait() können Sie mehrere Threads stoppen und mit notifyAll() alle Threads starten . Wenn mehrere Threads gestoppt wurden und notify() aufgerufen wurde, ist es unmöglich, genau zu sagen, welcher Thread diese Methode fortsetzt. Wenn es keine wartenden Threads für die Methode wait() gibt , passiert nichts, wenn notify() odernotifyAll() wird aufgerufen. Ein Thread kann die Methoden wait() oder notify() für ein bestimmtes Objekt nur aufrufen, wenn er derzeit eine Sperre für dieses Objekt hat. wait() , notify() und notifyAll() sollten nur aus synchronisiertem Code aufgerufen werden.

Beispiel für die Wait()-Methode

Hier haben wir eines der beliebtesten Beispiele, das veranschaulicht, wie die Methode funktioniert. Nehmen wir an, wir haben ein Geschäft, einen Produzenten und einen Verbraucher. Der Hersteller übergibt einige Produktionsprodukte an den Laden, woraufhin der Verbraucher sie mitnehmen kann. Der Hersteller muss jeweils 8 Waren produzieren, der Verbraucher muss sie alle kaufen. Gleichzeitig dürfen sich jedoch nicht mehr als 6 Artikel gleichzeitig im Lager befinden. Um dieses Problem zu lösen, verwenden wir die Methoden wait() und notify() . Definieren wir drei Klassen: Markt , Hersteller und Kunde . Der Hersteller in der run()- Methode fügt mithilfe von 8 Produkte zum Market- Objekt hinzuput()- Methode. Der Client in der run()- Methode ruft in einer Schleife die get-Methode des Market- Objekts auf, um diese Produkte abzurufen. Die Put- und Get-Methoden der Market- Klasse sind synchronisiert. Um das Vorhandensein von Waren in der Market- Klasse zu verfolgen, überprüfen wir den Wert der Artikelvariablen. Die get()- Methode zum Abrufen eines Produkts sollte nur ausgelöst werden, wenn mindestens ein Produkt vorhanden ist. Daher prüfen wir in der get-Methode, ob das Produkt fehlt. Wenn das Element nicht verfügbar ist, wird die Methode wait() aufgerufen. Diese Methode gibt den Monitor des Market- Objekts frei und blockiert die get-Methode, bis notify()Die Methode wird auf demselben Monitor aufgerufen. Wenn ein Element in der put()- Methode hinzugefügt und notify() aufgerufen wird, ruft die get()- Methode den Monitor ab. Danach erhält unser Kunde einen Artikel. Hierzu wird eine Meldung angezeigt und der Wert des Items dekrementiert. Schließlich signalisiert der Methodenaufruf notify() der Methode put(), fortzufahren. In der put() Methode funktioniert eine ähnliche Logik, nur sollte die put() Methode jetzt funktionieren, wenn nicht mehr als 6 Produkte im Market vorhanden sind .

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();
   }
}

Hier warten wir mit wait() in der get() Methode darauf, dass der Hersteller einen neuen Artikel hinzufügt. Und nach dem Hinzufügen rufen wir notify() auf , als wollten wir sagen, dass ein Platz im Warehouse frei geworden ist und Sie weitere hinzufügen können. In der put()- Methode warten wir mit wait() auf die Freigabe von Speicherplatz im Warehouse . Nachdem der Platz frei ist, fügen wir den Artikel hinzu, notify() startet den Thread und der Client kann den Artikel abholen. Hier ist die Ausgabe unseres Programms: