metodi wait and notify () in Java

1. Introduzione

In questo articolo vedremo uno dei meccanismi più fondamentali in Java: la sincronizzazione dei thread.

Per prima cosa discuteremo alcuni termini e metodologie essenziali relativi alla concorrenza.

E svilupperemo una semplice applicazione - dove ci occuperemo dei problemi di concorrenza, con l'obiettivo di comprendere meglio wait () e notify ().

2. Sincronizzazione dei thread in Java

In un ambiente multithread, più thread potrebbero provare a modificare la stessa risorsa. Se i thread non vengono gestiti correttamente, questo, ovviamente, porterà a problemi di coerenza.

2.1. Blocchi sorvegliati in Java

Uno strumento che possiamo utilizzare per coordinare le azioni di più thread in Java sono i blocchi protetti. Tali blocchi controllano una particolare condizione prima di riprendere l'esecuzione.

Con questo in mente, faremo uso di:

  • Object.wait () - per sospendere un thread
  • Object.notify () - per riattivare un thread

Questo può essere meglio compreso dal diagramma seguente, che rappresenta il ciclo di vita di un thread :

Si noti che esistono molti modi per controllare questo ciclo di vita; tuttavia, in questo articolo, ci concentreremo solo su wait () e notify ().

3. Il metodo wait ()

In poche parole, quando chiamiamo wait () - questo forza il thread corrente ad attendere fino a quando un altro thread invoca notify () o notifyAll () sullo stesso oggetto.

Per questo, il thread corrente deve possedere il monitor dell'oggetto. Secondo Javadocs, questo può accadere quando:

  • abbiamo eseguito il metodo di istanza sincronizzato per l'oggetto specificato
  • abbiamo eseguito il corpo di un blocco sincronizzato sull'oggetto dato
  • eseguendo metodi statici sincronizzati per oggetti di tipo Class

Notare che solo un thread attivo alla volta può possedere il monitor di un oggetto.

Questo metodo wait () viene fornito con tre firme sovraccaricate. Diamo un'occhiata a questi.

3.1. aspettare()

Il metodo wait () fa in modo che il thread corrente attenda indefinitamente fino a quando un altro thread invoca notify () per questo oggetto o notifyAll () .

3.2. aspetta (timeout lungo)

Utilizzando questo metodo, possiamo specificare un timeout dopo il quale il thread verrà riattivato automaticamente. Un thread può essere riattivato prima di raggiungere il timeout utilizzando notify () o notifyAll ().

Nota che chiamare wait (0) equivale a chiamare wait ().

3.3. aspetta (timeout lungo, int nanos)

Questa è un'altra firma che fornisce la stessa funzionalità, con l'unica differenza che possiamo fornire una maggiore precisione.

Il periodo di timeout totale (in nanosecondi) viene calcolato come 1_000_000 * timeout + nanos.

4. notify () e notifyAll ()

Il metodo notify () viene utilizzato per riattivare i thread che sono in attesa di un accesso al monitor di questo oggetto.

Esistono due modi per notificare i thread in attesa.

4.1. notificare()

Per tutti i thread in attesa sul monitor di questo oggetto (utilizzando uno qualsiasi del metodo wait () ), il metodo notify () notifica a uno di loro di svegliarsi arbitrariamente. La scelta di quale thread riattivare esattamente non è deterministica e dipende dall'implementazione.

Since notify() wakes up a single random thread it can be used to implement mutually exclusive locking where threads are doing similar tasks, but in most cases, it would be more viable to implement notifyAll().

4.2. notifyAll()

This method simply wakes all threads that are waiting on this object's monitor.

The awakened threads will complete in the usual manner – like any other thread.

But before we allow their execution to continue, always define a quick check for the condition required to proceed with the thread – because there may be some situations where the thread got woken up without receiving a notification (this scenario is discussed later in an example).

5. Sender-Receiver Synchronization Problem

Now that we understand the basics, let's go through a simple SenderReceiver application – that will make use of the wait() and notify() methods to set up synchronization between them:

  • The Sender is supposed to send a data packet to the Receiver
  • The Receiver cannot process the data packet until the Sender is finished sending it
  • Similarly, the Sender mustn't attempt to send another packet unless the Receiver has already processed the previous packet

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).

Per ulteriori informazioni sul pacchetto java.util.concurrent , visitare la nostra panoramica dell'articolo java.util.concurrent e Lock e Condition sono trattati nella guida a java.util.concurrent.Locks, qui.

Come sempre, gli snippet di codice completi utilizzati in questo articolo sono disponibili su GitHub.