Wait()-methode in Java

In dit artikel kijken we naar de methode wait() om threads te besturen en de methoden notification() / notifyAll() . Deze methoden zijn gedefinieerd in de basisklasse java.lang.Object en dienovereenkomstig bieden de overervingsmechanismen in Java deze methoden aan absoluut alle klassen. Dat wil zeggen, wanneer u uw eigen klasse en zijn objecten maakt, kunt u deze methoden altijd aanroepen.

Hoe werken de methoden wait() en notification()/notifyAll()?

• wacht() . in het kort, deze methode geeft de monitor vrij en plaatst de aanroepende thread in een wachttoestand totdat een andere thread de melding() / notifyAll() methode aanroept;
• melden() . Zet het werk voort van een thread waarvan de methode wait() eerder werd aangeroepen;
• De methode NotifyAll() hervat alle threads waarvan de methode Wait() eerder is aangeroepen.

Laten we nu de wait() methode eens nader bekijken . De klasse Object bevat drie opties voor deze methode:

• public final native void wait(lange time-outMillis) gooit InterruptedException ; Het zorgt ervoor dat de huidige thread wacht totdat deze wordt gewekt. Meestal gebeurt dit door een melding of onderbreking, of totdat een bepaalde hoeveelheid realtime is verstreken.

• public final void wait() genereert InterruptedException . Het is geen toeval dat we als tweede een methode zonder parameters schreven. Als je naar de code kijkt, verwijst het zelfs naar de eerste variant van de methode, het heeft alleen het 0L-argument.

• public final wait​(lange time-out, int nanos) . Zorgt ervoor dat de huidige thread wacht totdat deze wordt gewekt, meestal door een melding of onderbreking, of totdat een bepaalde hoeveelheid real-time is verstreken.

De methode wait() is bedoeld om de aanroepende thread op te schorten. Wat betekent het? Deze methoden behoren tot de klasse. Op basis van de klasse maak je een object. Objecten bestaan ​​in sommige threads. Dat wil zeggen, objecten worden in sommige threads gemaakt. In de thread waarin dit object werkt, als je wait() erin aanroept, zal dit ertoe leiden dat deze thread stopt. Het object zelf fungeert als een soort monitor. Wat is het? Het is duidelijk dat je verschillende objecten kunt maken en dat ze allemaal de wait() zullen bevattenmethode. Er is inzicht in welk object de stop van een bepaalde thread heeft veroorzaakt. De thread stopt en wacht zolang deze in de parameter is geschreven. En dan gaat het beginnen. Deze thread kan zichzelf niet starten. Om het werk te hervatten, zijn er melding en meldingAlle methoden. Een aanroep naar notification() of notificationAll() moet een andere thread afspelen. Met wait() kunt u meerdere threads stoppen en alle threads starten met notificationAll() . Als meerdere threads zijn gestopt en notification() is aangeroepen, is het onmogelijk om precies te zeggen welke thread deze methode zal hervatten. Als er geen wachtende threads zijn op de wait() methode, gebeurt er niets wanneer notification() orinformeerAll() wordt aangeroepen. Een thread kan de methode wait() of notification() voor een bepaald object alleen aanroepen als er momenteel een vergrendeling op dat object staat. wait() , notification() en notificationAll() mogen alleen worden aangeroepen vanuit gesynchroniseerde code.

Wacht() methode voorbeeld

Hier hebben we een van de meest populaire voorbeelden die illustreert hoe de methode werkt. Laten we zeggen dat we een winkel, een producent en een consument hebben. De fabrikant brengt enkele productieproducten over naar de winkel, waarna de consument ze kan meenemen. Stel dat de fabrikant respectievelijk 8 goederen moet produceren, dan moet de consument ze allemaal kopen. Maar tegelijkertijd kunnen er niet meer dan 6 artikelen tegelijk in het magazijn zijn. Om dit probleem op te lossen, gebruiken we de methode wait() en notification() . Laten we drie klassen definiëren: Markt , Fabrikant en Klant . De fabrikant in de methode run() voegt 8 producten toe aan het object Market met behulp van itsput() methode. De client in de methode run() roept in een lus de get-methode van het Market- object aan om deze producten op te halen. De put- en get-methoden van de klasse Market worden gesynchroniseerd. Om de aanwezigheid van goederen in de klasse Market te volgen , controleren we de waarde van de itemvariabele. De methode get() om een ​​product te krijgen mag alleen worden geactiveerd als er ten minste één product is. Daarom controleren we in de get-methode of het product ontbreekt. Als het item niet beschikbaar is, wordt de methode wait() aangeroepen. Deze methode geeft de monitor van het Market- object vrij en blokkeert de get-methode totdat de melding()methode wordt aangeroepen op dezelfde monitor. Wanneer een item wordt toegevoegd in de methode put() en attend() wordt aangeroepen, haalt de methode get() de monitor op. Daarna ontvangt onze klant een item. Hiervoor wordt een bericht weergegeven en wordt de waarde van het item verlaagd. Ten slotte signaleert de aanroep van de methode notify() de methode put() om door te gaan. In de methode put() werkt soortgelijke logica, alleen nu zou de methode put() moeten werken als er niet meer dan 6 producten op de markt zijn .

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, met behulp van wait() in de get() methode, wachten we tot de fabrikant een nieuw item toevoegt. En na het toevoegen bellen we attend() , alsof we willen zeggen dat er één plaats vrij is gekomen in het Warehouse en dat u er meer kunt toevoegen. In de methode put() wachten we met behulp van wait() op het vrijgeven van ruimte op de Warehouse . Nadat de ruimte vrij is, voegen we het item toe, attend() start de draad en de klant kan het item ophalen. Hier is de uitvoer van ons programma: