So verwenden Sie Wait and Notify in Java

Das Konzept von Multithreading in Java ist es wichtig zu verstehen, bevor Sie zu wechseln Warten() Und benachrichtigen() Methoden. Multithreading bezieht sich auf den Prozess, bei dem mehr als ein Thread versucht, auf eine gemeinsam genutzte Ressource zuzugreifen. Dieses Problem wurde mithilfe von Multithreading in Java durch Methoden wie gelöst warten, benachrichtigenUnd notifyall(). Die Objektklasse in Java verwendet diese Methoden, um die Probleme zu lösen, die durch Multithreading entstehen.

In diesem Artikel zeigen wir im Detail, wie man die Wait-and-Notify-Methode in Java implementiert.

Wie verwende ich Wait and Notify in Java?

Die Methoden wait() und notify() gelten als nützliche Methoden, die innerhalb der Objektklasse in Java deklariert werden. Die Methoden wait() und notify() funktionieren so, dass die Wait-Methoden den eingehenden Thread warten lassen, bis der Thread ihn verlässt. Der Thread benachrichtigt nun den eingehenden Thread mithilfe von benachrichtigen() Methode zur Eingabe.

Warten() Die Methode weist drei Varianten auf. Das Grundprinzip wird dargestellt als Warten(). Der warten (Zeitüberschreitung) Varianz wartet entweder bis zur Benachrichtigung oder bis zum Timeout. Die dritte Methode verwendet Timeout und ein Nanosekundenargument für zusätzliche Genauigkeit, die als dargestellt wird warten (Timeout, Nanosekunden).

Schauen wir uns nun die Syntax an:

object.notify()
object.wait()

Beispiel: Implementierung der Methoden wait() und notify()

Die Implementierung der Methoden wait() und notify() wird im folgenden Code dargestellt:

public class waitnotify {
  private static final long interval = 3000;
  private boolean run = true;
  private Thread thread;
  public void starting() {
          thread = new Thread(new Runnable() {
        @Override
        public void run() {
            print("First method");
            try {
                //make the thread to sleep
              Thread.sleep(interval);
              //exception for the current thread
            } catch(InterruptedException e) {
              Thread.currentThread().interrupt();
            }
            //notify the current thread
            synchronized(waitnotify.this) {
              run = false;
              waitnotify.this.notify();
            }
        }
      });
      thread.start();
  }
  public void joining() throws InterruptedException {
      print(“Second method");
      synchronized(this) {
        while(run) {
            print("Wait for the thread to finish.");
            //waiting, in process
            wait();
        }
        //the running thread has ended
        print("The current thread has finished running.");
      }
  }
  private void print(String s) {
      System.out.println(s);
  }
  public static void main(String[] args) throws InterruptedException {
      waitnotify testmethod = new waitnotify();
      //calling the starting method
      testmethod.starting();
      //calling the joiningmethod
      testmethod.joining();
  }
}

Im Code oben:

  • Es gibt ein Zeitintervall, in dem der Thread auf die angegebene Zeit wartet.
  • Die notify()-Methode wurde in den Try-Catch-Block eingeschlossen, da der wartende Thread eine Ausnahme auslöst, wenn er eine Unterbrechung erhält.
  • Der zweite Thread ist in Bearbeitung.
  • Der erste Thread wird für das angegebene Intervall in den Ruhezustand versetzt, bis er zum Aufwachen benachrichtigt wird.
  • Sobald der laufende Thread endet, wird der erste Thread benachrichtigt, aufzuwachen und auszuführen.

Ausgabe

In der obigen Ausgabe:

  • Die zweite Methode läuft entsprechend ab.
  • Die erste Methode wurde mithilfe von „sleep()“ für den angegebenen Zeitraum in den Ruhezustand versetzt.
  • Jetzt wird der erste Thread über die notify()-Methode zum Aufwecken benachrichtigt.
  • Am Ende sind alle Threads fertig.

Die obige Implementierung fasst zusammen, wie die Wait- und Notify-Methoden in Java verwendet und implementiert werden.

Abschluss

Die Methoden wait() und notify() werden in der Objektklasse von Java verwendet. Die beiden Methoden lösen das Problem des Multithreadings in Java. Die Methode „wait()“ lässt den Thread warten, bis der aktuelle Thread ausgeführt wird, während die Methode „notify()“ den wartenden Thread darüber benachrichtigt, dass die Ausführung des vorherigen Threads gestoppt wurde. Beide Methoden lösen das Problem der Synchronisation. In diesem Artikel wurde die effektive Implementierung beider Methoden demonstriert.

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen