Методы wait и notify () в Java

1. Введение

В этой статье мы рассмотрим один из самых фундаментальных механизмов в Java - синхронизацию потоков.

Сначала мы обсудим некоторые важные термины и методологии, связанные с параллелизмом.

И мы разработаем простое приложение, в котором мы будем иметь дело с проблемами параллелизма, с целью лучшего понимания wait () и notify ().

2. Синхронизация потоков в Java

В многопоточной среде несколько потоков могут попытаться изменить один и тот же ресурс. Если потоки не управляются должным образом, это, конечно, приведет к проблемам с согласованностью.

2.1. Охраняемые блоки в Java

Один из инструментов, который мы можем использовать для координации действий нескольких потоков в Java, - это охраняемые блоки. Такие блоки проверяют конкретное условие перед возобновлением выполнения.

Имея это в виду, мы будем использовать:

  • Object.wait () - приостановить поток
  • Object.notify () - разбудить поток

Это можно лучше понять из следующей диаграммы, которая отображает жизненный цикл потока :

Обратите внимание, что существует множество способов управления этим жизненным циклом; однако в этой статье мы сосредоточимся только на wait () и notify ().

3. Ожидание () Метод

Проще говоря, когда мы называем ожидание () - это заставляет текущий поток ждать , пока другой поток вызывает не уведомят () или notifyAll () на тот же объект.

Для этого текущий поток должен владеть монитором объекта. Согласно Javadocs, это может произойти, когда:

  • мы выполнили синхронизированный метод экземпляра для данного объекта
  • мы выполнили тело синхронизированного блока для данного объекта
  • путем выполнения синхронизированных статических методов для объектов типа Class

Обратите внимание, что только один активный поток может владеть монитором объекта одновременно.

Этот метод wait () имеет три перегруженных сигнатуры. Давайте посмотрим на них.

3.1. Подождите()

Ожидание () метод вызывает текущий поток ждать до бесконечности , пока другой поток , либо вызывает Notify () для этого объекта или notifyAll () .

3.2. ждать (долгое время ожидания)

Используя этот метод, мы можем указать тайм-аут, по истечении которого поток будет автоматически разбужен. Поток может быть разбужены до достижения тайм - аут , используя уведомить () или notifyAll ().

Обратите внимание, что вызов wait (0) аналогичен вызову wait ().

3.3. ждать (долгий таймаут, int nanos)

Это еще одна сигнатура, обеспечивающая ту же функциональность, с той лишь разницей, что мы можем обеспечить более высокую точность.

Общий период ожидания (в наносекундах) рассчитывается как 1_000_000 * тайм-аут + наносекунды .

4. notify () и notifyAll ()

Метод notify () используется для пробуждения потоков, ожидающих доступа к монитору этого объекта.

Есть два способа уведомления ожидающих потоков.

4.1. уведомлять()

Для всех потоков, ожидающих на мониторе этого объекта (с помощью любого из методов wait () ), метод notify () уведомляет любой из них о произвольном пробуждении. Выбор того, какой именно поток активировать, не является детерминированным и зависит от реализации.

Поскольку notify () пробуждает один случайный поток, его можно использовать для реализации взаимоисключающей блокировки, когда потоки выполняют аналогичные задачи, но в большинстве случаев было бы более целесообразно реализовать notifyAll () .

4.2. notifyAll ()

Этот метод просто будит все потоки, ожидающие на мониторе этого объекта.

Пробужденные потоки завершатся обычным образом - как и любой другой поток.

Но прежде чем мы позволим их выполнению продолжаться, всегда определяйте быструю проверку условия, необходимого для продолжения потока, потому что могут быть некоторые ситуации, когда поток просыпается без получения уведомления (этот сценарий обсуждается позже в примере) .

5. Проблема синхронизации отправителя и получателя.

Теперь, когда мы понимаем основы, давайте рассмотрим простое приложение Sender - Receiver, которое будет использовать методы wait () и notify () для настройки синхронизации между ними:

  • Отправитель должен послать пакет данных в приемник
  • Приемник не может обрабатывать пакет данных до тех пор , отправитель не будет завершен отправкой
  • Точно так же Отправитель не должен пытаться отправить другой пакет, если Получатель уже не обработал предыдущий пакет.

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

Для получения дополнительной информации о пакете java.util.concurrent посетите наш обзор статьи java.util.concurrent, а блокировка и условие описаны в руководстве по java.util.concurrent.Locks здесь.

Как всегда, полные фрагменты кода, использованные в этой статье, доступны на GitHub.