Java生产者-消费者问题中，如何避免线程阻塞并实现正确方案？

本文共计1317个文字，预计阅读时间需要6分钟。

相关专题

本文深入剖析 java 原生 wait()/notify() 实现生产者-消费者模型时常见的「无限等待」死锁问题，指出同步对象错用、notify() 调用时机不当、缺少循环等待条件检查等核心缺陷，并提供线程安全、逻辑严谨的修复代码与最佳实践。

在 Java 多线程编程中，生产者-消费者模式是经典同步问题，但初学者常因对 Object.wait() 和 notify() 的底层机制理解不足而陷入虚假唤醒（spurious wakeup） 或通知丢失（missed signal） 陷阱。原代码中两个线程均在 Shop.LL 上调用 wait()，却在 wait() 之后 才调用 notify() —— 这导致：一旦某个线程先执行 wait() 进入等待状态，而另一线程尚未开始或已执行完 notify()，该通知将被彻底丢弃，造成永久阻塞。

? 核心错误分析

1. notify() 调用位置错误
   原代码中 notify() 写在 synchronized 块内，但位于 wait() 之后（如 Producer 线程中 Shop.LL.wait() 后才 notify()），此时 notify() 实际唤醒的是自己（无意义），而非等待中的消费者；同理，消费者也试图唤醒自己。

2. 未使用 while 循环检查条件（违反 wait-loop 惯例）
   wait() 可能被意外唤醒（如 JVM 信号、超时等），必须用 while (condition) 而非 if (condition) 包裹 wait()，否则可能在条件不满足时继续执行，引发 IndexOutOfBoundsException 或逻辑错误。

3. notify() vs notifyAll() 的误用
   单一生产者/消费者场景下，notify() 理论可行，但极易因竞争顺序导致唤醒失败；实践中应优先使用 notifyAll()，确保所有等待线程重新竞争锁并校验条件。

4. 同步粒度与职责混乱
   Producer.produce() 和 Consumer.buy() 自身声明为 synchronized，但其锁对象是类 Class（Producer.class），与 Shop.LL 实例锁完全无关，形成「假同步」—— 无法保护共享资源 Shop.LL。

✅ 正确实现要点（基于 wait/notify）

以下为修复后的精简可运行示例，聚焦关键逻辑：

立即学习“Java免费学习笔记（深入）”；

import java.util.LinkedList; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; public class ProducerConsumerDemo { private static final String[] FRUITS = {"apple", "orange", "pineapple", "banana", "cherry", "kiwi"}; protected static final List<String> BUFFER = new LinkedList<>(); protected static final AtomicInteger producerIndex = new AtomicInteger(0); protected static final AtomicInteger consumerIndex = new AtomicInteger(0); public static void main(String[] args) throws InterruptedException { Thread producer = new Thread(() -> { synchronized (BUFFER) { // 【关键】循环检查：缓冲区非空则等待 while (!BUFFER.isEmpty()) { try { System.out.println("Producer waiting: buffer not empty"); BUFFER.wait(); // 释放锁，进入 WAITING 状态 } catch (InterruptedException e) { Thread.currentThread().interrupt(); return; } } // 生产全部水果 for (String fruit : FRUITS) { BUFFER.add(fruit); System.out.println("Produced: " + fruit); } BUFFER.notifyAll(); // 【关键】唤醒所有等待者（消费者） } }); Thread consumer = new Thread(() -> { synchronized (BUFFER) { // 【关键】循环检查：缓冲区为空则等待 while (BUFFER.isEmpty()) { try { System.out.println("Consumer waiting: buffer empty"); BUFFER.wait(); // 释放锁，进入 WAITING 状态 } catch (InterruptedException e) { Thread.currentThread().interrupt(); return; } } // 消费全部 while (!BUFFER.isEmpty()) { String item = BUFFER.remove(0); System.out.println("Consumed: " + item); } BUFFER.notifyAll(); // 【关键】唤醒所有等待者（生产者） } }); consumer.start(); producer.start(); producer.join(); consumer.join(); } }

⚠️ 注意事项与最佳实践

• 永远用 while 包裹 wait()：这是 Javadoc 明确要求的模式，避免虚假唤醒导致条件不成立却继续执行。
• notifyAll() 优于 notify()：尤其在多线程复杂场景下，notify() 可能唤醒错误线程，而 notifyAll() 让所有线程重新校验条件，更健壮。
• 同步块必须覆盖完整临界区：从条件检查 → wait() → 修改共享状态 → notifyAll()，全程需同一把锁（此处为 BUFFER 对象锁）。
• 避免嵌套同步或锁升级：不要在 synchronized (obj) 内部再调用其他 synchronized 方法（除非明确知道其锁对象一致）。
• 现代替代方案推荐：生产环境建议使用 java.util.concurrent 工具类，如 BlockingQueue（ArrayBlockingQueue, LinkedBlockingQueue），它内部已完美封装 wait/notify 逻辑，支持超时、公平性等高级特性，代码更简洁安全：

// 推荐：使用 BlockingQueue（无需手动 wait/notify） BlockingQueue<String> queue = new LinkedBlockingQueue<>(10); // 生产者：queue.put(item); // 阻塞直到有空间 // 消费者：queue.take(); // 阻塞直到有元素

通过理解 wait/notify 的协作契约（必须在同步块内、必须循环检查条件、必须由持有同一锁的线程调用），并严格遵循上述规范，即可彻底规避「线程无限等待」问题，写出健壮的生产者-消费者实现。