Verwenden Sie die Wait()- und Notify()-Methoden in Java

Dieses Tutorial demonstriert die Methoden wait() und notify() in Java.

Verwenden Sie die Methoden wait() und notify() in Java

Die Methoden wait() und notify() bieten einen Mechanismus, mit dem der Thread warten kann, bis eine bestimmte Bedingung erfüllt ist. Zum Beispiel, wenn Sie eine Sperrwarteschlangenimplementierung für einen Hintergrundspeicher von Elementen mit fester Größe schreiben möchten.

Die wait() und notify() werden in den bewachten Blöcken in Java verwendet, die die Aktionen mehrerer Threads koordinieren. Die Methode wait() wird verwendet, um einen Thread zu unterbrechen, und notify(), um den Thread aufzuwecken.

die wait()-Methode

Die Methode wait() zwingt den aktuellen Thread zu warten, bis einige andere Threads abgeschlossen sind, oder sie rufen die Methoden notify() oder notifyAll() für dasselbe Objekt auf. Die wait()-Methoden können auf folgende Arten verwendet werden:

1. Mit wait():

   Dies ist der einfache Aufruf der wait()-Methode, die dazu führt, dass der aktuelle Thread unbegrenzt wartet, bis die anderen Threads die notify()- oder notifyAll()-Methoden aufrufen.

2. Mit wait(long timeout):

   Mit diesem Aufruf der wait()-Methode können wir ein Timeout angeben, nach dem der Thread automatisch aufgeweckt wird, wobei timeout ein langer Zeitwert ist.

   Mit den Methoden notify() und notifyAll() kann der Thread auch vor dem Timeout aufgeweckt werden. Der Wert 0 im Timeout-Parameter funktioniert ähnlich wie der wait()-Aufruf.

3. Mit wait(long timeout, int nanos):

   Auch dieser Aufruf funktioniert ähnlich wie wait(long timeout). Der einzige Unterschied besteht darin, dass wir eine höhere Präzision liefern können.

   Die Timeout-Periode wird in Nanosekunden als 1_000_000*timeout + nanos. berechnet.

die Methoden notify() und notifyAll()

Die notify()-Funktionalität wird verwendet, um die Threads aufzuwecken, die darauf warten, auf den Objektmonitor zuzugreifen. Die Funktion notify() kann auf zwei Arten verwendet werden:

1. Mit notify():

   Für alle wartenden Threads benachrichtigt die notify()-Methode nur einen bestimmten Thread zum Aufwachen. Die Auswahl des aufzuweckenden Threads ist nicht deterministisch, was von der Implementierung abhängt.

   Da notify() nur einen Thread aufwecken kann, ist es möglicherweise nicht sinnvoll, wenn wir mehrere Threads aufwecken wollen.

2. Verwendung von notifyAll():

   notifyAll() weckt alle Threads auf dem Objektmonitor auf. Wenn die Threads aufgeweckt werden, werden sie wie die anderen Threads auf die übliche Weise abgeschlossen.

Versuchen wir ein Beispiel, das die Threads mit der Methode wait() blockiert und mit der Methode notify() aufwacht:

package delftstack;

import java.util.LinkedList;
import java.util.Queue;

public class Example<T> {
  private Queue<T> Demo_Queue = new LinkedList<T>();
  private int Q_Capacity;

  public Example(int Q_Capacity) {
    this.Q_Capacity = Q_Capacity;
  }

  public synchronized void put(T Demo_Element) throws InterruptedException {
    while (Demo_Queue.size() == Q_Capacity) {
      wait();
    }

    Demo_Queue.add(Demo_Element);
    // Wake up the thread. notifyAll() can also be used for multiple threads
    notify();
  }

  public synchronized T take() throws InterruptedException {
    while (Demo_Queue.isEmpty()) {
      // Ask the thread to wait
      wait();
    }

    T item = Demo_Queue.remove();
    // Wake up the thread. notifyAll() can also be used for multiple threads
    notify();
    return item;
  }
}

Der obige Code zeigt eine einfache Warteschlangenblockierungsoperation, bei der wir sicherstellen müssen, dass sich alle wait()- und notify()-Aufrufe im synchronisierten Bereich des Codes befinden.