Java是目前最流行的编程语言之一，其并发编程能力也是相当强大的。在多线程编程中，线程间的通信无疑是非常关键的。Java提供了多种方式来实现线程间通信，其中最常见的方式之一就是使用对象的wait()和notify()方法。这种方式不仅简单易用，而且在Java中广泛应用于各种场景下。
一、wait-notify机制的概述
wait-notify机制是Java中实现线程间通信的一种机制。它通过在不同的线程之间共享对象来实现线程间的通信。具体来说，某个线程调用对象的wait()方法后，会让该线程处于等待状态，并且该线程释放所持有的对象锁；而另一个线程调用该对象的notify()方法后，会使得等待中的线程被唤醒并且重新竞争对象锁。因此，wait-notify机制可以帮助我们更好地控制线程的执行。
二、wait-notify机制的使用
1. wait()方法
java.lang.Object提供了wait()方法，用于将当前的线程置入“睡眠”状态，且只有等待另一个线程来唤醒此线程。wait()方法常用于线程间交互/通信的场合，通常有线程A调用了对象的wait()方法进入等待状态，而线程B调用了相同对象的notify()或notifyAll()方法，使得该对象的等待线程重新进入可运行状态。
/**
* wait方法
*/
public class WaitDemo implements Runnable{
private static Object object = new Object();
@Override
public void run() {
synchronized (object){
try {
System.out.println(Thread.currentThread().getName() + " wait开始..");
object.wait();
System.out.println(Thread.currentThread().getName() + " 被唤醒..");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
WaitDemo waitDemo1 = new WaitDemo();
WaitDemo waitDemo2 = new WaitDemo();
Thread thread1 = new Thread(waitDemo1, "线程1");
Thread thread2 = new Thread(waitDemo2, "线程2");
thread1.start();
thread2.start();
System.out.println("主线程睡眠2秒开始..");
Thread.sleep(2000); //主线程睡眠3秒
System.out.println("主线程睡眠2秒结束..");
synchronized (object){
object.notifyAll();
}
System.out.println("主线程唤醒等待线程结束..");
}
}
注意事项：
- wait方法必须使用在synchronized同步中。
- wait方法会释放锁，而notity方法不会释放锁。
- wait方法和notify,notifyAll方法不会自动释放锁。
2. notify()方法
java.lang.Object提供了notify()方法，唤醒一个因调用了wait()方法而处于阻塞状态的线程。
/**
* notify方法
*/
public class NotifyDemo implements Runnable{
private static Object object = new Object();
@Override
public void run() {
synchronized (object){
System.out.println(Thread.currentThread().getName() + " 进入等待状态..");
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 被唤醒..");
}
}
public static void main(String[] args) {
NotifyDemo notifyDemo = new NotifyDemo();
Thread thread1 = new Thread(notifyDemo, "线程1");
Thread thread2 = new Thread(notifyDemo, "线程2");
thread1.start();
thread2.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (object){
object.notify(); //随机唤醒一个线程
//object.notifyAll(); 唤醒所有线程
}
System.out.println("主线程唤醒所有线程结束..");
}
}
三、wait-notify机制的注意事项
1. Wait和Notify的阻塞队列
线程在争取到锁之后，如果发现自己无法继续执行，就会释放锁，并进入该锁对象的等待队列(wait-set)中。在锁被释放的同时，该线程也进入到该锁的等待队列中，并且会挂起线程。当锁被另一个线程重新竞争并成功获取后，它就会唤醒该锁等待队列中的某个线程，唤醒的操作由notify或者notifyAll方法完成。
2. 避免因过多的notify()而导致の虚假唤醒（Spurious Wakeup）问题
由于操作系统底层的原因，某些情况下JVM会在没有notify()调用的情况下自动唤醒waiting线程。例如：CPU资源不足，只要有线程有等待状态结束了，它就会进行唤醒操作。
为了避免这种情况的发生，往往需要将在wait()的时候用while来判断条件，以保证线程在唤醒后，会重新判断条件并决定是否执行后续的工作。以下是一个示例代码：
/**
* 避免虚假唤醒问题
*/
public class WaitNotifyDemo implements Runnable{
private static final Object object = new Object();
private static boolean flag;
@Override
public void run() {
synchronized (object){
while (!flag){
try {
System.out.println(Thread.currentThread().getName() + "等待中..");
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "被唤醒..");
}
}
public static void main(String[] args) {
WaitNotifyDemo waitNotifyDemo = new WaitNotifyDemo();
Thread thread1 = new Thread(waitNotifyDemo, "线程1");
Thread thread2 = new Thread(waitNotifyDemo, "线程2");
thread1.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (object){
flag = true;
System.out.println("flag = true，唤醒所有线程..");
object.notifyAll();
}
}
}
总结
本文介绍了Java中实现线程间通信的利器——wait-notify机制。wait-notify机制通过在不同的线程之间共享对象来实现线程间的通信，使用起来简单易懂，适用于各种场景。然而在使用过程中，需注意wait-notify机制的细节和注意事项。我们通过编写示例代码，希望能帮助读者更好地理解wait-notify机制。
