wait and notify () Methoden in Java

1. Einleitung

In diesem Artikel werden wir uns einen der grundlegendsten Mechanismen der Java-Thread-Synchronisation ansehen.

Wir werden zunächst einige wesentliche Begriffe und Methoden im Zusammenhang mit der Parallelität erörtern.

Und wir werden eine einfache Anwendung entwickeln, in der wir uns mit Parallelitätsproblemen befassen, um wait () und notify () besser zu verstehen .

2. Thread-Synchronisation in Java

In einer Multithread-Umgebung versuchen möglicherweise mehrere Threads, dieselbe Ressource zu ändern. Wenn Threads nicht ordnungsgemäß verwaltet werden, führt dies natürlich zu Konsistenzproblemen.

2.1. Geschützte Blöcke in Java

Ein Werkzeug, mit dem wir Aktionen mehrerer Threads in Java koordinieren können, sind geschützte Blöcke. Solche Blöcke überprüfen eine bestimmte Bedingung, bevor die Ausführung fortgesetzt wird.

In diesem Sinne werden wir Folgendes verwenden:

  • Object.wait () - um einen Thread anzuhalten
  • Object.notify () - um einen Thread aufzuwecken

Dies lässt sich anhand des folgenden Diagramms besser verstehen, das den Lebenszyklus eines Threads darstellt :

Bitte beachten Sie, dass es viele Möglichkeiten gibt, diesen Lebenszyklus zu steuern. In diesem Artikel konzentrieren wir uns jedoch nur auf wait () und notify ().

3. Die wait () -Methode

Einfach gesagt, wenn wir rufen wait () - Dies zwingt den aktuellen Thread warten , bis einige andere Thread aufruft notify () oder notifyAll () auf demselben Objekt.

Dazu muss der aktuelle Thread den Monitor des Objekts besitzen. Laut Javadocs kann dies passieren, wenn:

  • Wir haben eine synchronisierte Instanzmethode für das angegebene Objekt ausgeführt
  • Wir haben den Hauptteil eines synchronisierten Blocks für das angegebene Objekt ausgeführt
  • durch Ausführen synchronisierter statischer Methoden für Objekte vom Typ Klasse

Beachten Sie, dass jeweils nur ein aktiver Thread den Monitor eines Objekts besitzen kann.

Diese wait () -Methode enthält drei überladene Signaturen. Schauen wir uns diese an.

3.1. warten()

Die wait () Methode bewirkt , dass der aktuelle Thread auf unbestimmte Zeit , bis ein anderer Thread warten , entweder Invokes notify () für dieses Objekt oder notifyAll () .

3.2. warte (lange Auszeit)

Mit dieser Methode können wir ein Timeout angeben, nach dem der Thread automatisch aufgeweckt wird. Ein Thread kann die Zeitüberschreitung erreicht aufgeweckt werden vor der Verwendung notify () oder notifyAll ().

Beachten Sie, dass das Aufrufen von wait (0) dasselbe ist wie das Aufrufen von wait ().

3.3. warten (lange Auszeit, int nanos)

Dies ist eine weitere Signatur, die dieselbe Funktionalität bietet. Der einzige Unterschied besteht darin, dass wir eine höhere Präzision erzielen können.

Die gesamte Zeitüberschreitungsperiode (in Nanosekunden) wird als 1_000_000 * Zeitüberschreitung + Nanos berechnet .

4. notify () und notifyAll ()

Die notify () -Methode wird zum Aufwecken von Threads verwendet, die auf einen Zugriff auf den Monitor dieses Objekts warten.

Es gibt zwei Möglichkeiten, wartende Threads zu benachrichtigen.

4.1. benachrichtigen()

Für alle Threads, die auf dem Monitor dieses Objekts warten (unter Verwendung einer der wait () -Methoden), benachrichtigt die Methode notify () einen von ihnen, um willkürlich aufzuwecken. Die Wahl, welcher Thread genau aktiviert werden soll, ist nicht deterministisch und hängt von der Implementierung ab.

Da notify () einen einzelnen zufälligen Thread aufweckt, kann es verwendet werden, um sich gegenseitig ausschließende Sperren zu implementieren, wenn Threads ähnliche Aufgaben ausführen. In den meisten Fällen wäre es jedoch sinnvoller, notifyAll () zu implementieren .

4.2. notifyAll ()

Diese Methode weckt einfach alle Threads, die auf dem Monitor dieses Objekts warten.

Die aufgeweckten Fäden werden auf die übliche Weise vervollständigt - wie jeder andere Faden.

Bevor wir jedoch zulassen, dass die Ausführung fortgesetzt wird, definieren Sie immer eine schnelle Überprüfung der Bedingung, die erforderlich ist, um mit dem Thread fortzufahren. In einigen Situationen wurde der Thread möglicherweise ohne Benachrichtigung aufgeweckt (dieses Szenario wird später in einem Beispiel erläutert.) .

5. Sender-Empfänger-Synchronisationsproblem

Nun , da wir die Grundlagen verstehen, gehen sie durch einen einfachen Sender - Empfänger Anwendung - dass die Verwendung des machen wait () und notify () Methoden Synchronisation zwischen ihnen einzurichten:

  • Der Absender soll ein Datenpaket an den Empfänger senden
  • Der Empfänger kann das Datenpaket erst verarbeiten, wenn der Absender das Senden beendet hat
  • Ebenso darf der Absender nicht versuchen, ein anderes Paket zu senden, es sei denn, der Empfänger hat das vorherige Paket bereits verarbeitet

Let's first create Data class that consists of the data packet that will be sent from Sender to Receiver. We'll use wait() and notifyAll() to set up synchronization between them:

public class Data { private String packet; // True if receiver should wait // False if sender should wait private boolean transfer = true; public synchronized void send(String packet) { while (!transfer) { try { wait(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); Log.error("Thread interrupted", e); } } transfer = false; this.packet = packet; notifyAll(); } public synchronized String receive() { while (transfer) { try { wait(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); Log.error("Thread interrupted", e); } } transfer = true; notifyAll(); return packet; } }

Let's break down what's going on here:

  • The packet variable denotes the data that is being transferred over the network
  • We have a boolean variable transfer – which the Sender and Receiver will use for synchronization:
    • If this variable is true, then the Receiver should wait for Sender to send the message
    • If it's false, then Sender should wait for Receiver to receive the message
  • The Sender uses send() method to send data to the Receiver:
    • If transfer is false, we'll wait by calling wait() on this thread
    • But when it is true, we toggle the status, set our message and call notifyAll() to wake up other threads to specify that a significant event has occurred and they can check if they can continue execution
  • Similarly, the Receiver will use receive() method:
    • If the transfer was set to false by Sender, then only it will proceed, otherwise we'll call wait() on this thread
    • When the condition is met, we toggle the status, notify all waiting threads to wake up and return the data packet that was Receiver

5.1. Why Enclose wait() in a while Loop?

Since notify() and notifyAll() randomly wakes up threads that are waiting on this object's monitor, it's not always important that the condition is met. Sometimes it can happen that the thread is woken up, but the condition isn't actually satisfied yet.

We can also define a check to save us from spurious wakeups – where a thread can wake up from waiting without ever having received a notification.

5.2. Why Do We Need to Synchronize send() and receive() Methods?

We placed these methods inside synchronized methods to provide intrinsic locks. If a thread calling wait() method does not own the inherent lock, an error will be thrown.

We'll now create Sender and Receiver and implement the Runnable interface on both so that their instances can be executed by a thread.

Let's first see how Sender will work:

public class Sender implements Runnable { private Data data; // standard constructors public void run() { String packets[] = { "First packet", "Second packet", "Third packet", "Fourth packet", "End" }; for (String packet : packets) { data.send(packet); // Thread.sleep() to mimic heavy server-side processing try { Thread.sleep(ThreadLocalRandom.current().nextInt(1000, 5000)); } catch (InterruptedException e) { Thread.currentThread().interrupt(); Log.error("Thread interrupted", e); } } } }

For this Sender:

  • We're creating some random data packets that will be sent across the network in packets[] array
  • For each packet, we're merely calling send()
  • Then we're calling Thread.sleep() with random interval to mimic heavy server-side processing

Finally, let's implement our Receiver:

public class Receiver implements Runnable { private Data load; // standard constructors public void run() { for(String receivedMessage = load.receive(); !"End".equals(receivedMessage); receivedMessage = load.receive()) { System.out.println(receivedMessage); // ... try { Thread.sleep(ThreadLocalRandom.current().nextInt(1000, 5000)); } catch (InterruptedException e) { Thread.currentThread().interrupt(); Log.error("Thread interrupted", e); } } } }

Here, we're simply calling load.receive() in the loop until we get the last “End” data packet.

Let's now see this application in action:

public static void main(String[] args) { Data data = new Data(); Thread sender = new Thread(new Sender(data)); Thread receiver = new Thread(new Receiver(data)); sender.start(); receiver.start(); }

We'll receive the following output:

First packet Second packet Third packet Fourth packet 

And here we are – we've received all data packets in the right, sequential order and successfully established the correct communication between our sender and receiver.

6. Conclusion

In this article, we discussed some core synchronization concepts in Java; more specifically, we focused on how we can use wait() and notify() to solve interesting synchronization problems. And finally, we went through a code sample where we applied these concepts in practice.

Before we wind down here, it's worth mentioning that all these low-level APIs, such as wait(), notify() and notifyAll() – are traditional methods that work well, but higher-level mechanism are often simpler and better – such as Java's native Lock and Condition interfaces (available in java.util.concurrent.locks package).

Weitere Informationen zum Paket java.util.concurrent finden Sie in unserer Übersicht über den Artikel java.util.concurrent. Sperren und Bedingungen finden Sie im Handbuch zu java.util.concurrent.Locks hier.

Wie immer sind die vollständigen Codefragmente, die in diesem Artikel verwendet werden, auf GitHub verfügbar.