изчакайте и уведомете () Методи в Java

Програмиране

1. Въведение

В тази статия ще разгледаме един от най-фундаменталните механизми в Java - синхронизация на нишки.

Първо ще обсъдим някои съществени термини и методологии, свързани със съвпадението.

И ние ще разработим просто приложение - където ще се справим с проблеми на едновременността, с цел по-добро разбиране wait () и notify ().

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

В многонишкова среда множество нишки могат да се опитат да модифицират един и същ ресурс. Ако нишките не се управляват правилно, това, разбира се, ще доведе до проблеми с последователността.

2.1. Защитени блокове в Java

Един инструмент, който можем да използваме, за да координираме действията на множество нишки в Java - е защитени блокове. Такива блокове поддържат проверка за конкретно състояние, преди да подновят изпълнението.

Имайки това предвид, ще използваме:

  • Object.wait () - за спиране на нишка
  • Object.notify () - за събуждане на нишка

Това може да се разбере по-добре от следната диаграма, която изобразява жизнения цикъл на нишка :

Моля, имайте предвид, че има много начини за контролиране на този жизнен цикъл; обаче в тази статия ще се съсредоточим само върху wait () и уведомяване ().

3. изчакване () метод

Просто казано, когато извикаме wait () - това принуждава текущата нишка да изчака, докато друга нишка извика notify () или notifyAll () за същия обект.

За това текущата нишка трябва да притежава монитора на обекта. Според Javadocs това може да се случи, когато:

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

Имайте предвид, че само една активна нишка може да притежава монитор на обект наведнъж.

Този метод wait () идва с три претоварени подписа. Нека да разгледаме тези.

3.1. изчакайте()

Методът wait () кара текущата нишка да чака безкрайно, докато друга нишка или извика notify () за този обект, или notifyAll () .

3.2. изчакайте (дълъг таймаут)

Използвайки този метод, можем да посочим време за изчакване, след което нишката ще се събуди автоматично. Нишка може да се събуди, преди да достигне времето за изчакване с помощта на notify () или notifyAll ().

Имайте предвид, че извикването на изчакване (0) е същото като извикване на изчакване ().

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.