在Java并发编程中,处理线程间的同步与协作是至关重要的一环。传统的循环等待(也称为忙等待或自旋等待)方式,虽然简单直观,但在多线程环境中却极易导致CPU资源的浪费和效率低下。特别是当线程需要等待某个条件成立时,如果采用循环检查该条件的方式,不仅会无谓地消耗CPU资源,还可能因为过高的CPU占用率而影响到系统的整体性能。为了优化这种情况,Java并发包(java.util.concurrent)提供了丰富的同步机制,其中“等待-通知”模式(Wait-Notify Mechanism)是一种非常有效且广泛使用的解决方案。
“等待-通知”机制是Java中用于线程间通信的一种模式,它依赖于Object类中的wait()
、notify()
和notifyAll()
三个方法来实现。这三个方法都是java.lang.Object类的成员,因此Java中的任何对象都可以作为同步锁和通信媒介。
notify()
方法或notifyAll()
方法。调用wait()
方法之前,线程必须获得该对象的锁。调用wait()
方法后,线程会释放这个锁,并进入等待队列中等待。notify()
方法之前,线程也必须获得该对象的锁。在不使用“等待-通知”机制的情况下,当线程需要等待某个条件满足时,可能会采用循环检查的方式来实现。这种方式虽然简单,但存在明显的问题:
通过“等待-通知”机制,我们可以有效地避免循环等待带来的问题。其基本思想是:当线程需要等待某个条件时,不是通过循环检查,而是调用wait()
方法进入等待状态,并释放锁;当条件满足时,另一个线程会调用notify()
或notifyAll()
方法唤醒等待的线程,并重新竞争锁以继续执行。
为了更直观地说明“等待-通知”机制的应用,我们以经典的生产者-消费者问题为例进行说明。
场景描述:有一个共享的资源(如缓冲区),生产者线程负责向其中生产数据,消费者线程负责从中消费数据。生产者必须在缓冲区未满时才能生产,消费者必须在缓冲区非空时才能消费。
不使用“等待-通知”机制的实现(简化版,仅作对比):
public class Buffer {
private final int capacity;
private int size = 0;
private final List<Integer> items = new ArrayList<>();
public Buffer(int capacity) {
this.capacity = capacity;
}
public synchronized void produce(int item) throws InterruptedException {
while (size == capacity) {
Thread.sleep(100); // 简单的等待方式,实际应用中应避免
}
items.add(item);
size++;
}
public synchronized int consume() throws InterruptedException {
while (size == 0) {
Thread.sleep(100); // 同样是简单的等待方式
}
int item = items.remove(0);
size--;
return item;
}
}
使用“等待-通知”机制的实现:
public class Buffer {
private final int capacity;
private int size = 0;
private final List<Integer> items = new ArrayList<>();
private final Object lock = new Object(); // 显式锁对象
public Buffer(int capacity) {
this.capacity = capacity;
}
public void produce(int item) throws InterruptedException {
synchronized (lock) {
while (size == capacity) {
lock.wait(); // 等待空间
}
items.add(item);
size++;
lock.notifyAll(); // 通知可能在等待的消费者
}
}
public int consume() throws InterruptedException {
synchronized (lock) {
while (size == 0) {
lock.wait(); // 等待数据
}
int item = items.remove(0);
size--;
lock.notifyAll(); // 通知可能在等待的生产者
return item;
}
}
}
在这个优化后的实现中,我们使用了显式的锁对象lock
来同步访问缓冲区和进行线程间的通信。当缓冲区满时,生产者线程会调用lock.wait()
进入等待状态,并释放锁;当消费者消费了数据后,通过调用lock.notifyAll()
唤醒所有等待的线程(包括生产者和消费者),但通常情况下,由于条件限制,只有生产者或消费者中的一个会被唤醒并继续执行。
wait()
方法可能在没有被notify()
或notifyAll()
显式唤醒的情况下就返回了,这被称为虚假唤醒(Spurious Wakeup)。因此,在wait()
的循环中应该总是重新检查条件是否满足。wait()
、notify()
和notifyAll()
方法必须在同步块或同步方法中调用,且这些方法的调用对象必须是同一个对象,即同步锁。notifyAll()
而非notify()
:除非你有明确的理由知道只有一个线程会等待某个条件,否则通常应该使用notifyAll()
来唤醒所有等待的线程,以避免潜在的死锁或活锁问题。通过“等待-通知”机制,我们可以有效地优化Java并发编程中的循环等待问题,提高系统的响应性和效率。在生产者-消费者等典型场景中,这一机制显得尤为重要。理解和掌握“等待-通知”机制是Java并发编程的基础,也是提升程序性能和稳定性的关键。