wait and notify () Méthodes en Java

1. Introduction

Dans cet article, nous examinerons l'un des mécanismes les plus fondamentaux de la synchronisation des threads Java.

Nous aborderons d'abord quelques termes et méthodologies essentiels liés à la concurrence.

Et nous allons développer une application simple - où nous traiterons les problèmes de concurrence, dans le but de mieux comprendre wait () et notify ().

2. Synchronisation des threads en Java

Dans un environnement multithread, plusieurs threads peuvent essayer de modifier la même ressource. Si les threads ne sont pas gérés correctement, cela entraînera bien sûr des problèmes de cohérence.

2.1. Blocs gardés à Java

Un outil que nous pouvons utiliser pour coordonner les actions de plusieurs threads en Java - est les blocs protégés. Ces blocs vérifient une condition particulière avant de reprendre l'exécution.

Dans cet esprit, nous utiliserons:

  • Object.wait () - pour suspendre un thread
  • Object.notify () - pour réveiller un thread

Cela peut être mieux compris à partir du diagramme suivant, qui décrit le cycle de vie d'un thread :

Veuillez noter qu'il existe de nombreuses façons de contrôler ce cycle de vie; cependant, dans cet article, nous allons nous concentrer uniquement sur wait () et notify ().

3. La méthode wait ()

En termes simples, lorsque nous appelons wait () - cela force le thread actuel à attendre qu'un autre thread appelle notify () ou notifyAll () sur le même objet.

Pour cela, le thread actuel doit posséder le moniteur de l'objet. Selon Javadocs, cela peut se produire lorsque:

  • nous avons exécuté la méthode d'instance synchronisée pour l'objet donné
  • nous avons exécuté le corps d'un bloc synchronisé sur l'objet donné
  • en exécutant des méthodes statiques synchronisées pour les objets de type Class

Notez qu'un seul thread actif peut posséder le moniteur d'un objet à la fois.

Cette méthode wait () est fournie avec trois signatures surchargées. Jetons un coup d'œil à ceux-ci.

3.1. attendez()

La méthode wait () oblige le thread actuel à attendre indéfiniment jusqu'à ce qu'un autre thread appelle notify () pour cet objet ou notifyAll () .

3.2. attendre (long timeout)

En utilisant cette méthode, nous pouvons spécifier un délai après lequel le thread sera automatiquement réveillé. Un thread peut être réveillé avant d'atteindre le délai d'expiration en utilisant notify () ou notifyAll ().

Notez que l'appel de wait (0) est identique à l'appel de wait ().

3.3. wait (long timeout, int nanos)

C'est encore une autre signature offrant la même fonctionnalité, la seule différence étant que nous pouvons fournir une plus grande précision.

Le délai d'expiration total (en nanosecondes) est calculé comme 1_000_000 * timeout + nanos.

4. notifier () et notifierAll ()

La méthode notify () est utilisée pour réveiller les threads qui attendent un accès au moniteur de cet objet.

Il existe deux façons de notifier les threads en attente.

4.1. notifier ()

Pour tous les threads en attente sur le moniteur de cet objet (en utilisant l'une des méthodes wait () ), la méthode notify () notifie à l'un d'entre eux de se réveiller arbitrairement. Le choix exact du thread à réveiller n'est pas déterministe et dépend de l'implémentation.

Puisque notify () réveille un seul thread aléatoire, il peut être utilisé pour implémenter un verrouillage mutuellement exclusif où les threads effectuent des tâches similaires, mais dans la plupart des cas, il serait plus viable d'implémenter notifyAll () .

4.2. notifyAll ()

Cette méthode réveille simplement tous les threads en attente sur le moniteur de cet objet.

Les threads éveillés se termineront de la manière habituelle - comme n'importe quel autre thread.

Mais avant de permettre à leur exécution de continuer, définissez toujours une vérification rapide de la condition requise pour continuer avec le thread - car il peut y avoir des situations où le thread s'est réveillé sans recevoir de notification (ce scénario est discuté plus loin dans un exemple) .

5. Problème de synchronisation expéditeur-récepteur

Maintenant que nous comprenons les bases, passons par une simple application Sender - Receiver - qui utilisera les méthodes wait () et notify () pour configurer la synchronisation entre elles:

  • L' expéditeur est censé envoyer un paquet de données au récepteur
  • Le destinataire ne peut pas traiter le paquet de données tant que l' expéditeur n'a pas fini de l'envoyer
  • De même, l' expéditeur ne doit pas tenter d'envoyer un autre paquet à moins que le récepteur n'ait déjà traité le paquet précédent

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

Pour plus d'informations sur le package java.util.concurrent , consultez notre présentation de l'article java.util.concurrent, et le verrouillage et la condition sont traités dans le guide de java.util.concurrent.Locks, ici.

Comme toujours, les extraits de code complets utilisés dans cet article sont disponibles à l'adresse over sur GitHub.