Interviewer asked: What are the functions of the wait and notify methods in threads?

1. Introduction

In the previous thread series article, we introduced the synchronized and volatile keywords, which can solve the problem of thread synchronization, but they cannot solve the problem of coordination and communication between threads.

To give a simple example, thread A is responsible for adding the value of the int variable i to 10000, and then notifies thread B to print out the result.

How to achieve this? One of the simplest ways is that thread B continuously checks whether the condition is met through polling while(i == 10000).

Although this method can meet the requirements, it also brings another problem: the while() operation in thread B will not release CPU resources, causing the CPU to always perform judgment operations on this method, greatly wasting CPU resources.

We know that CPU resources are very expensive, because CPU resources are used not only by the current application, but also by many other applications. If the polling time is released and used by other threads, the running efficiency of the application can be significantly improved. For example, after thread A completes the operation, it notifies thread B to perform subsequent operations. Thread B does not need to complete the coordination between threads through polling. Isn't this better?

In the parent class of Java, that is, the Object class, there are three methods: wait(), notify(), and notifyAll(), which can realize communication between threads.

If you have never used multithreading, you may not use these methods. Let's take a look at how to use them!

2. Method Introduction

• wait()

The wait() method, as the name suggests, means waiting. Its function is to put the thread executing the current code into a blocked state, put the current thread into the "pre-execution queue", and stop executing the code where wait() is located until it is notified or interrupted.

However, there is a prerequisite. Before calling the wait() method, the thread must obtain the lock of the object. Therefore, the wait() method can only be called in the synchronized method/synchronized code block modified by synchronized. At the same time, after the wait() method is executed, the acquired object lock will be released immediately for other threads to use. The current thread is blocked and enters the waiting state.

As for why wait() has a blocking effect, its internal mechanism is very complicated and is mainly implemented by the C code of the JVM. You just need to understand it.

• notify()

The notify() method, as the name suggests, means notification. Its function is to reawaken the waiting threads under the same monitor. If there are multiple threads waiting, a waiting thread is randomly selected and a notify() is sent to it, making it wait to acquire the object lock of the object.

Note "waiting to acquire the object lock of the object", which means that even if the notification is received, the waiting thread will not immediately acquire the object lock, and must wait for the thread of the notify() method to release the lock.

The calling environment is the same as wait(). notify() must also be called in a synchronized method/synchronized code block modified by synchronized.

• notifyAll()

The notifyAll() method, as the name implies, also means notification. Its function is to reawaken all waiting threads under the same monitor. The notify() method will only wake up one thread randomly, while the notifyAll() method will wake up all threads at once.

Generally speaking, the notifyAll() method is safer, because when our code logic is not well considered, using notify() will result in only waking up one thread, while other threads may wait forever and cannot wake up.

The calling environment is the same as notify(). notifyAll() must also be called in a synchronized method/synchronized code block modified by synchronized.

The three methods can be summarized as follows:

• 1.wait() method blocks the thread and enters the waiting state
• 2. notify() method wakes up the waiting thread. If there are multiple threads, randomly select one from them.
• 3. notifyAll() method wakes up all waiting threads

2.1、Introduction to wait/notify/notifyAll

Usually the wait() method is often used in conjunction with notify() or notifyAll().

Let's look at a simple example.

 public class MyThreadA extends Thread{ private Object lock; public MyThreadA(Object lock) { this.lock = lock; } @Override public void run() { synchronized (lock){ System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " wait begin"); try { // 进入阻塞等待lock.wait(); } catch (Exception e) { e.printStackTrace(); } System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " wait end"); } } }

 public class MyThreadB extends Thread{ private Object lock; public MyThreadB(Object lock) { this.lock = lock; } @Override public void run() { synchronized (lock){ System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " notify begin"); // 唤醒其它等待线程lock.notify(); System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " notify end"); } } }

 public class MyThreadTest { public static void main(String[] args) throws InterruptedException { Object lock = new Object(); MyThreadA threadA = new MyThreadA(lock); threadA.start(); //过3秒再启动下一个线程Thread.sleep(3000); MyThreadB threadB = new MyThreadB(lock); threadB.start(); } }

Running the service, the output is as follows:

 2023-09-28 16:42:19 当前线程：Thread-0 wait begin 2023-09-28 16:42:22 当前线程：Thread-1 notify begin 2023-09-28 16:42:22 当前线程：Thread-1 notify end 2023-09-28 16:42:22 当前线程：Thread-0 wait end

From the log, we can see that threadA starts first, then enters a blocked state. After 3 seconds, threadB is started. After the execution is completed, threadA is notified that it can acquire the object lock and the execution is completed.

This is basically the coordination and communication between threads.

If we increase the number of threadA threads to 5, let's take a look at the running results.

 public class MyThreadTest { public static void main(String[] args) throws InterruptedException { Object lock = new Object(); // 创建5个wait线程for (int i = 0; i < 5; i++) { MyThreadA threadA = new MyThreadA(lock); threadA.start(); } //过3秒再启动下一个线程Thread.sleep(3000); MyThreadB threadB = new MyThreadB(lock); threadB.start(); } }

Running the service, the output is as follows:

 2023-09-28 17:02:05 当前线程：Thread-0 wait begin 2023-09-28 17:02:05 当前线程：Thread-4 wait begin 2023-09-28 17:02:05 当前线程：Thread-3 wait begin 2023-09-28 17:02:05 当前线程：Thread-2 wait begin 2023-09-28 17:02:05 当前线程：Thread-1 wait begin 2023-09-28 17:02:08 当前线程：Thread-5 notify begin 2023-09-28 17:02:08 当前线程：Thread-5 notify end 2023-09-28 17:02:08 当前线程：Thread-0 wait end

From the log, we can clearly see that when multiple threads are in a waiting state, calling the notify() method will only wake up one of the waiting threads; at the same time, the service cannot be closed because the remaining 4 threads are always in a blocked state.

Suppose we change the lock.notify() method in the MyThreadB class to the lock.notifyAll() method and see what the effect is.

 public class MyThreadB extends Thread{ private Object lock; public MyThreadB(Object lock) { this.lock = lock; } @Override public void run() { synchronized (lock){ System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " notify begin"); // 唤醒所有等待的线程lock.notifyAll(); System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " notify end"); } } }

Running the service, the output is as follows:

 2023-09-28 17:18:13 当前线程：Thread-0 wait begin 2023-09-28 17:18:13 当前线程：Thread-4 wait begin 2023-09-28 17:18:13 当前线程：Thread-3 wait begin 2023-09-28 17:18:13 当前线程：Thread-2 wait begin 2023-09-28 17:18:13 当前线程：Thread-1 wait begin 2023-09-28 17:18:16 当前线程：Thread-5 notify begin 2023-09-28 17:18:16 当前线程：Thread-5 notify end 2023-09-28 17:18:16 当前线程：Thread-1 wait end 2023-09-28 17:18:16 当前线程：Thread-2 wait end 2023-09-28 17:18:16 当前线程：Thread-3 wait end 2023-09-28 17:18:16 当前线程：Thread-4 wait end 2023-09-28 17:18:16 当前线程：Thread-0 wait end

It can be clearly seen from the log that after 3 seconds all waiting threads are awakened and the service ends.

2.2. Introduction to wait lock release

In multi-threaded programming, you should always pay attention to locks because they play an important role in whether the current code is executed safely.

As we mentioned above, calling the wait() method not only blocks the thread and puts it into a waiting state, but also releases the lock.

We can see this by looking at a simple example.

 public class MyThreadA1 extends Thread{ private Object lock; public MyThreadA1(Object lock) { this.lock = lock; } @Override public void run() { synchronized (lock){ System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " wait begin"); try { // 进入阻塞等待lock.wait(); } catch (Exception e) { e.printStackTrace(); } System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " wait end"); } } }

 public class MyThreadTest1 { public static void main(String[] args) throws InterruptedException { Object lock = new Object(); // 创建两个调用wait的线程MyThreadA1 threadA1 = new MyThreadA1(lock); threadA1.start(); MyThreadA1 threadA2 = new MyThreadA1(lock); threadA2.start(); } }

Running the service, the output is as follows:

 2023-09-28 17:31:56 当前线程：Thread-0 wait begin 2023-09-28 17:31:56 当前线程：Thread-1 wait begin

It can be clearly seen from the log results that after one of the two threads calls lock.wait(), it enters a blocked state and releases the object lock. The other thread obtains the lock and enters the synchronized code block, so wait begin is printed for both threads.

There is also a sleep() method in the Thread class that can block the current thread, but there is a difference between them. The sleep() method will not allow the current thread to release the lock.

Let's look at a simple example.

 public class MyThreadA1 extends Thread{ private Object lock; public MyThreadA1(Object lock) { this.lock = lock; } @Override public void run() { synchronized (lock){ System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " sleep begin"); try { // 进入阻塞等待Thread.sleep(100); } catch (Exception e) { e.printStackTrace(); } System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " sleep end"); } } }

 public class MyThreadTest1 { public static void main(String[] args) throws InterruptedException { Object lock = new Object(); // 创建两个调用sleep的线程MyThreadA1 threadA1 = new MyThreadA1(lock); threadA1.start(); MyThreadA1 threadA2 = new MyThreadA1(lock); threadA2.start(); } }

Running the service, the output is as follows:

 2023-09-28 17:55:20 当前线程：Thread-0 sleep begin 2023-09-28 17:55:21 当前线程：Thread-0 sleep end 2023-09-28 17:55:21 当前线程：Thread-1 sleep begin 2023-09-28 17:55:21 当前线程：Thread-1 sleep end

From the log, it can be seen that the threads are not executed alternately, but serially.

2.3. Introduction to notify/notifyAll not releasing locks

Corresponding to this are notify() and notifyAll(). Calling the notify() or notifyAll() method will not release the lock of the current thread. The lock will only be released when the synchronization method/synchronization code block is executed.

Again, let's look at a simple example.

 public class MyThreadA2 extends Thread{ private Object lock; public MyThreadA2(Object lock) { this.lock = lock; } @Override public void run() { synchronized (lock){ System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " notify begin"); // 唤醒其它等待线程lock.notify(); System.out.println(DateUtil.format(new Date()) + " 当前线程：" + Thread.currentThread().getName() + " notify end"); } } }

 public class MyThreadTest2 { public static void main(String[] args) throws InterruptedException { Object lock = new Object(); // 创建两个调用notify()的线程MyThreadA2 threadA1 = new MyThreadA2(lock); threadA1.start(); MyThreadA2 threadA2 = new MyThreadA2(lock); threadA2.start(); } }

Running the service, the output is as follows:

 2023-09-28 18:11:36 当前线程：Thread-0 notify begin 2023-09-28 18:11:36 当前线程：Thread-0 notify end 2023-09-28 18:11:36 当前线程：Thread-1 notify begin 2023-09-28 18:11:36 当前线程：Thread-1 notify end

It can be clearly seen from the log results that the two threads are not executed alternately, but serially.

2.4. IllegalMonitorStateException

Although the wait(), notify(), and notifyAll() methods are in the Object class and can be called directly by any class in theory, they cannot be called anywhere. If these three methods are called outside of a synchronized method or synchronized code block, a java.lang.IllegalMonitorStateException will be thrown when the program is running.

Let's take a look at a simple example to understand.

 public class MyThreadTest3 { public static void main(String[] args) throws Exception { Object lock = new Object(); lock.wait(); } }

Run the program and throw an exception directly.

 Exception in thread "main" java.lang.IllegalMonitorStateException at java.lang.Object.wait(Native Method) at java.lang.Object.wait(Object.java:502) at com.example.thread.e3.MyThreadTest3.main(MyThreadTest3.java:19)

Changing to notify() and notifyAll(), the running results are the same.

3. Summary

This article mainly summarizes some knowledge about the coordination and communication technologies between threads. The wait(), notify(), and notifyAll() methods in the Object class can be used to achieve coordination and communication between threads, but they are only effective in synchronized methods/synchronized code blocks. If they are not called in synchronized methods/synchronized code blocks, a java.lang.IllegalMonitorStateException will be thrown.

There are bound to be omissions in the article content, netizens are welcome to leave comments and point them out!

IV. Reference

1. Liao Xuefeng - Introduction to wait and notify

2. Cangjie in May - Introduction to wait() and notify()/notifyAll()