一、先看下 Condition的使用案例：
经典案例：生产者-消费者问题（面包店模型）
/**
* 面包店：生产者做面包，消费者买面包
* - 货架最多放5个面包
* - 货架满时，生产者要等待
* - 货架空时，消费者要等待
*/
public class Bakery {
private final Queue<String> shelf = new LinkedList<>(); // 货架
private final int CAPACITY = 5; // 货架容量
private final Lock lock = new ReentrantLock();
// 创建两个条件：货架"非满"和"非空"
private final Condition notFull = lock.newCondition(); // 用于生产者等待
private final Condition notEmpty = lock.newCondition(); // 用于消费者等待
/**
* 生产者：制作面包
*/
public void produceBread(String breadName) throws InterruptedException {
lock.lock();
try {
// 如果货架满了，生产者就要等待"货架非满"这个条件
while (shelf.size() == CAPACITY) {
System.out.println("货架已满，" + Thread.currentThread().getName() + " 等待中...");
notFull.await(); // 释放锁，进入等待状态
}
// 货架有空间了，放上面包
shelf.offer(breadName);
System.out.println(Thread.currentThread().getName() + " 制作了: " + breadName +
"，货架现有: " + shelf.size() + "个面包");
// 通知消费者：货架现在"非空"了，可以来买了
notEmpty.signal();
} finally {
lock.unlock();
}
}
/**
* 消费者：购买面包
*/
public String consumeBread() throws InterruptedException {
lock.lock();
try {
// 如果货架空了，消费者就要等待"货架非空"这个条件
while (shelf.isEmpty()) {
System.out.println("货架已空，" + Thread.currentThread().getName() + " 等待中...");
notEmpty.await(); // 释放锁，进入等待状态
}
// 货架有面包了，取走一个
String bread = shelf.poll();
System.out.println(Thread.currentThread().getName() + " 购买了: " + bread +
"，货架剩余: " + shelf.size() + "个面包");
// 通知生产者：货架现在"非满"了，可以继续生产了
notFull.signal();
return bread;
} finally {
lock.unlock();
}
}
}
测试代码
public class BakeryTest {
public static void main(String[] args) {
Bakery bakery = new Bakery();
// 创建2个生产者线程
for (int i = 1; i <= 2; i++) {
new Thread(() -> {
try {
for (int j = 1; j <= 10; j++) {
bakery.produceBread("面包-" + Thread.currentThread().getName() + "-" + j);
Thread.sleep(100); // 模拟制作时间
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, "生产者" + i).start();
}
// 创建3个消费者线程
for (int i = 1; i <= 3; i++) {
new Thread(() -> {
try {
for (int j = 1; j <= 7; j++) {
bakery.consumeBread();
Thread.sleep(150); // 模拟购买时间
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, "消费者" + i).start();
}
}
}
完整流程分析
场景1：货架未满，多个生产者竞争
// 假设当前货架有3个面包（未满）
// 生产者1和生产者2同时到达
生产者1: lock.lock() 成功获取锁
生产者2: lock.lock() ❌ 阻塞等待（因为锁被生产者1持有）
// 生产者1继续执行
生产者1: 检查货架未满 → 制作面包 → notEmpty.signal() → lock.unlock()
// 生产者1释放锁后
生产者2: 从阻塞状态被唤醒，成功获取锁 → 检查货架 → 制作面包...
关键点：在货架未满时，生产者之间是公平竞争锁的关系。
场景2：货架已满，Condition 开始发挥作用
// 假设货架已经有5个面包（满了）
// 生产者1先获取锁
生产者1: lock.lock() 成功
生产者1: 检查货架已满 → notFull.await()
// 重点来了！在await() 方法内部：
1. 生产者1会**自动释放锁**（这样其他线程就能获取锁了）
2. 生产者1线程进入等待状态，被挂起
// 此时锁被释放，消费者可以获取锁了
消费者1: lock.lock() 成功获取锁
消费者1: 购买面包 → notFull.signal() → lock.unlock()
// notFull.signal() 唤醒了在 notFull 条件上等待的生产者1
生产者1: 从 await() 中醒来，但需要**重新获取锁**才能继续执行
注意：生产者因为调用**notFull.await()**进入notFull队列等待，并且会释放锁，当消费者通过notFull.signal()唤醒生成者的时候，是从notFull.await()这行代码继续执行，只不过还要获取锁，如果没有获取到就要等待，但是他不需要写lock.lock();这种代码。这里需要注意，生产者执行notFull.await()代码，只是释放锁和进入等待，没有做唤醒消费者动作。
notFull.await()做了什么
//1、也就是执行notFull.await()这个代码，里面做了好几个事情，先创建等待队列，
//2、然后释放锁，自己挂起等待，唤醒后还要在获取一次锁。用伪代码表示就是下面：
public final void await() throws InterruptedException {
// 1. 创建新的节点加入到条件队列
Node node = addConditionWaiter();
// 2. 完全释放当前线程持有的锁（让其他线程可以获取锁）
int savedState = fullyReleaseLock();
// 3. 将当前线程挂起，进入等待状态
while (!isOnSyncQueue(node)) {
LockSupport.park(this);
}
// 4. 被唤醒后，需要重新获取锁
acquireQueued(node, savedState);
}
生产者1获取锁 → 检查货架已满 → 调用 notFull.await()
↓
自动释放锁，线程挂起
↓
消费者获取锁 → 购买面包 → 调用 notFull.signal()
↓
生产者1被唤醒，尝试重新获取锁
↓
成功获取锁后，从await()方法继续执行
整体执行流程：
生产者1 尝试获取锁...
生产者1 成功获取锁
生产者2 尝试获取锁... ← 生产者2在这里阻塞
货架已满，生产者1 开始等待... ← 生产者1调用await()释放锁
生产者2 成功获取锁 ← 生产者2立即获取到锁
货架已满，生产者2 也开始等待... ← 生产者2调用await()释放锁
消费者1 尝试获取锁...
消费者1 成功获取锁
消费者1 购买了面包
消费者1 唤醒了生产者1
消费者1 释放锁
生产者1 被唤醒，重新检查条件 ← 生产者1需要重新获取锁
生产者1 成功获取锁 ← 获取锁成功
生产者1 制作了: 面包+1
生产者1 释放锁
问题
问题：当多个生产者调用notFull.await();后，被消费者唤醒，那么唤醒的顺序是按进入notFull的顺序唤醒的吗？
是的，FIFO（先进先出）顺序唤醒的，被唤醒的顺序严格按进入 await()的顺序，
与锁的公平性无关。但是获取锁的顺序，这取决于使用的 Lock 是公平锁还是非公平锁。
二、如果使用synchronized实现：
/**
* 使用 synchronized 实现的有界缓冲区
*/
public class BoundedBufferSynchronized {
private final Queue<String> buffer = new LinkedList<>();
private final int capacity;
public BoundedBufferSynchronized(int capacity) {
this.capacity = capacity;
}
/**
* 生产者方法
*/
public void produce(String item) throws InterruptedException {
synchronized (this) { // 使用 synchronized 块
// 如果缓冲区已满，等待
while (buffer.size() == capacity) {
System.out.println(Thread.currentThread().getName() + ": 缓冲区已满，等待中...");
wait(); // 释放锁，进入等待
}
// 生产物品
buffer.offer(item);
System.out.println(Thread.currentThread().getName() + " 生产了: " + item + "，当前数量: " + buffer.size());
// 通知所有等待的线程（包括生产者和消费者）
notifyAll();
}
}
/**
* 消费者方法
*/
public String consume() throws InterruptedException {
synchronized (this) {
// 如果缓冲区为空，等待
while (buffer.isEmpty()) {
System.out.println(Thread.currentThread().getName() + ": 缓冲区为空，等待中...");
wait(); // 释放锁，进入等待
}
// 消费物品
String item = buffer.poll();
System.out.println(Thread.currentThread().getName() + " 消费了: " + item +
"，当前数量: " + buffer.size());
// 通知所有等待的线程
notifyAll();
return item;
}
}
public synchronized int size() {
return buffer.size();
}
}
测试代码：
public class SynchronizedProducerConsumerTest {
public static void main(String[] args) {
BoundedBufferSynchronized buffer = new BoundedBufferSynchronized(3);
// 生产者线程
Thread producer1 = new Thread(() -> {
try {
for (int i = 1; i <= 5; i++) {
buffer.produce("产品-" + Thread.currentThread().getName() + "-" + i);
Thread.sleep(100);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, "生产者1");
Thread producer2 = new Thread(() -> {
try {
for (int i = 1; i <= 5; i++) {
buffer.produce("产品-" + Thread.currentThread().getName() + "-" + i);
Thread.sleep(150);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, "生产者2");
// 消费者线程
Thread consumer1 = new Thread(() -> {
try {
for (int i = 1; i <= 6; i++) {
buffer.consume();
Thread.sleep(200);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, "消费者1");
Thread consumer2 = new Thread(() -> {
try {
for (int i = 1; i <= 4; i++) {
buffer.consume();
Thread.sleep(180);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, "消费者2");
producer1.start();
producer2.start();
consumer1.start();
consumer2.start();
try {
producer1.join();
producer2.join();
consumer1.join();
consumer2.join();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println("最终缓冲区大小: " + buffer.size());
}
}
synchronized 实现的严重缺点
“惊群效应”（最严重的缺点）
生产者
while (buffer.size() == capacity) {
wait(); // 生产者等待
}
// ... 生产面包 ...
notifyAll(); // 唤醒所有线程
消费者
while (buffer.isEmpty()) {
wait(); // 消费者等待
}
// ... 消费 ...
notifyAll(); // 唤醒所有线程
问题分析：
当生产者生产一个产品后调用 notifyAll()，会唤醒所有等待的线程
包括：其他生产者 + 所有消费者
但被唤醒的生产者发现缓冲区仍然满，只能继续等待
造成大量不必要的线程唤醒和上下文切换。大量不必要的线程唤醒、频繁的线程上下文切换、CPU 资源浪费、在高并发场景下性能严重下降
无法实现精确通知
// 我们真正想要的是：
生产者生产 → 只唤醒消费者
消费者消费 → 只唤醒生产者
// 但 synchronized 只能：
生产者生产 → 唤醒所有线程（生产者和消费者）
消费者消费 → 唤醒所有线程（生产者和消费者）
- 性能问题
由于频繁的"惊群效应"，导致：大量不必要的线程唤醒、频繁的线程上下文切换、
CPU 资源浪费、在高并发场景下性能严重下降
总结：synchronized 实现的缺点
1、惊群效应：notifyAll()唤醒所有线程，造成大量不必要的唤醒
2、无法精确通知：不能针对特定条件的线程进行唤醒
3、性能较差：在高并发场景下，频繁的无效唤醒导致性能下降
4、功能有限：缺少超时、中断等高级特性
5、公平性不可控：无法实现公平锁
什么时候可以用 synchronized？
1、虽然有这么多的缺点，但 synchronized在以下场景仍然适用：
2、简单的同步场景：线程数量少，竞争不激烈
3、代码简洁性优先：快速开发，逻辑简单
4、性能要求不高：不是性能关键路径
但对于复杂的生产者-消费者场景，Lock + Condition 是明显更好的选择。
扫一扫
1570
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
