Wait and notify () Methods di Java

1. Perkenalan

Pada artikel ini, kita akan melihat salah satu mekanisme paling mendasar di Java - sinkronisasi utas.

Kami pertama-tama akan membahas beberapa istilah dan metodologi terkait konkurensi penting.

Dan kita akan mengembangkan aplikasi sederhana - di mana kita akan menangani masalah konkurensi, dengan tujuan lebih memahami wait () dan notify ().

2. Sinkronisasi Thread di Java

Dalam lingkungan multithread, beberapa utas mungkin mencoba mengubah sumber daya yang sama. Jika utas tidak dikelola dengan benar, ini tentu saja akan menyebabkan masalah konsistensi.

2.1. Blok yang Dijaga di Jawa

Satu alat yang dapat kita gunakan untuk mengoordinasikan tindakan beberapa utas di Java - adalah blok yang dilindungi. Blok semacam itu terus memeriksa kondisi tertentu sebelum melanjutkan eksekusi.

Dengan mengingat hal itu, kami akan menggunakan:

  • Object.wait () - untuk menangguhkan utas
  • Object.notify () - untuk membangunkan utas

Ini bisa lebih dipahami dari diagram berikut, yang menggambarkan siklus hidup Thread :

Harap perhatikan bahwa ada banyak cara untuk mengontrol siklus hidup ini; Namun, dalam artikel ini, kita hanya akan fokus pada wait () dan notify ().

3. menunggu () Method

Sederhananya, ketika kita memanggil wait () - ini memaksa utas saat ini menunggu hingga beberapa utas lain memanggil notify () atau notifyAll () pada objek yang sama.

Untuk ini, utas saat ini harus memiliki monitor objek. Menurut Javadocs, hal ini dapat terjadi jika:

  • kami telah mengeksekusi metode instance tersinkronisasi untuk objek yang diberikan
  • kita telah mengeksekusi badan blok tersinkronisasi pada objek yang diberikan
  • dengan menjalankan metode statis tersinkronisasi untuk objek bertipe Class

Perhatikan bahwa hanya satu utas aktif yang dapat memiliki monitor objek dalam satu waktu.

Metode wait () ini hadir dengan tiga tanda tangan yang kelebihan beban. Mari kita lihat ini.

3.1. Tunggu()

Metode wait () menyebabkan utas saat ini menunggu tanpa batas hingga utas lain memanggil notify () untuk objek ini atau notifyAll () .

3.2. tunggu (waktu tunggu lama)

Dengan menggunakan metode ini, kita dapat menentukan waktu tunggu setelah utas mana yang akan dibangunkan secara otomatis. Sebuah utas bisa dibangunkan sebelum mencapai waktu tunggu menggunakan notify () atau notifyAll ().

Perhatikan bahwa memanggil wait (0) sama dengan memanggil wait ().

3.3. tunggu (waktu tunggu lama, int nanos)

Ini adalah tanda tangan lain yang menyediakan fungsionalitas yang sama, dengan satu-satunya perbedaan adalah kami dapat memberikan presisi yang lebih tinggi.

Periode waktu tunggu total (dalam nanodetik), dihitung sebagai 1_000_000 * batas waktu + nanos.

4. notify () dan notifyAll ()

Metode notify () digunakan untuk membangunkan thread yang menunggu akses ke monitor objek ini.

Ada dua cara untuk memberi tahu utas menunggu.

4.1. memberitahu()

Untuk semua utas yang menunggu di monitor objek ini (dengan menggunakan salah satu metode wait () ), metode notify () memberi tahu salah satu dari mereka untuk bangun secara sewenang-wenang. Pilihan utas mana yang akan diaktifkan tidak bersifat deterministik dan bergantung pada implementasinya.

Karena notify () membangunkan satu utas acak, ini bisa digunakan untuk mengimplementasikan penguncian yang saling eksklusif di mana utas melakukan tugas serupa, tetapi dalam banyak kasus, akan lebih layak untuk mengimplementasikan notifyAll () .

4.2. notifyAll ()

Metode ini hanya membangunkan semua utas yang menunggu di monitor objek ini.

Utas yang terbangun akan selesai dengan cara biasa - seperti utas lainnya.

Tetapi sebelum kami mengizinkan eksekusi mereka untuk melanjutkan, selalu tentukan pemeriksaan cepat untuk kondisi yang diperlukan untuk melanjutkan dengan utas - karena mungkin ada beberapa situasi di mana utas dibangunkan tanpa menerima pemberitahuan (skenario ini dibahas nanti dalam contoh) .

5. Masalah Sinkronisasi Pengirim-Penerima

Sekarang setelah kita memahami dasar-dasarnya, mari melalui aplikasi Pengirim - Penerima sederhana - yang akan menggunakan metode wait () dan notify () untuk mengatur sinkronisasi di antara mereka:

  • The Pengirim seharusnya mengirim paket data ke Receiver
  • The Receiver tidak dapat memproses paket data sampai Sender selesai mengirimnya
  • Demikian pula, Pengirim tidak boleh mencoba mengirim paket lain kecuali Penerima telah memproses paket sebelumnya

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

Untuk informasi lebih lanjut tentang paket java.util.concurrent , kunjungi ikhtisar artikel java.util.concurrent kami, dan Kunci dan Ketentuan tercakup dalam panduan untuk java.util.concurrent.Locks, di sini.

Seperti biasa, cuplikan kode lengkap yang digunakan dalam artikel ini tersedia di GitHub.