Java 设计模式之 Producer-Consumer(生产者-消费者)模式:用有界缓冲区解耦生产与消费

原创2026-10-02 17:00:401,953 阅读
文章标签:示例工程教程

Java 设计模式之 Producer-Consumer(生产者-消费者)模式:用有界缓冲区解耦生产与消费

Producer-Consumer 是 Java 并发编程中最经典的模式之一,它通过一个共享的有界缓冲区(Bounded Buffer)将"生产数据"与"消费数据"两类工作彻底分离,让生产者和消费者以各自独立的节奏并行运转。本文以 java-design-patterns 仓库中的 producer-consumer 模块为实例,从核心类实现、线程调度到测试验证逐层剖析该模式,读完你将掌握如何用 BlockingQueue 实现安全高效的生产-消费流水线,并能直接运行、扩展这一示例。

模式目的

生产者-消费者设计模式是一种经典的并发模式,其核心思想是将"工作的识别"与"工作的执行"相分离,从而降低生产者(Producer)与消费者(Consumer)之间的耦合度。

在典型场景中,生产者负责产生数据/任务,消费者负责处理数据/任务,二者通过一个共享队列完成交接。这种分离带来两个直接收益:

  • 生产者和消费者的代码可以独立编写、独立演进;
  • 两者可以以不同的速度并行工作——当生产者快于消费者时,多余的工作在缓冲区中排队;当消费者快于生产者时,消费者可以从缓冲区中取到之前积压的任务继续处理。

该模式在 Java 中也被称为 有界缓冲区(Bounded Buffer) 或 Consumer-Producer 模式。

类图与参与者

Producer-Consumer 模式类图

从类图可以看出,本模块由四个核心参与者构成(源码位于 producer-consumer/src/main/java/com/iluwatar/producer/consumer):

参与者 职责 源码文件
Item 生产者与消费者之间传递的数据单元(record) Item.java
ItemQueue 有界共享缓冲区,是生产与消费的交接通道 ItemQueue.java
Producer 生产 Item 并放入队列 Producer.java
Consumer 从队列取出 Item 并消费 Consumer.java

ItemQueue 作为缓冲区,其容量固定为 5,是整个模式中"同步"与"背压(backpressure)"机制的载体。

真实世界类比:汽车装配流水线

为了直观理解该模式,可以把它想象成一条汽车制造流水线:

  • 生产者:发动机装配工位,负责组装发动机;
  • 消费者:发动机安装工位,负责把发动机装进车体;
  • 缓冲区:两台工位之间的传送带。

发动机装配完成后被放到传送带上,安装工位再从传送带上取下发动机进行安装。装配与安装两个环节互不阻塞:当装配速度高于安装速度时,多余的发动机暂时存放在传送带上;当装配工位临时停工而安装工位急需发动机时,安装工位仍可继续消耗传送带上已有的库存。这正是生产-消费解耦的真实写照——它提供了一种在多个以不同速率运行的循环之间共享数据的途径。

这一经典问题可追溯到 Edsger Dijkstra 的描述:"我们考虑两个进程,分别称为'生产者'和'消费者'。生产者是一个周期性进程,它产生一定量的信息,这些信息必须由消费者处理;消费者也是一个周期性进程,它需要处理生产者已经产生的下一部分信息。我们假设这两个进程通过一个容量无界的缓冲区连接。"

程序化示例:Java 实现剖析

下面以仓库中完整的示例代码为线索,逐层理解该模式的 Java 实现。示例的业务场景是:一条"物品制造流水线",当生产管道已满时生产者需要暂停生产,当管道为空时消费者需要暂停消费——生产与消费各自独立、分别暂停,但整体协同工作。

1. 数据单元:Item

生产与消费传递的数据单元是一个简洁的 Java record,包含生产者名称与自增序号两个字段:

public record Item(String producer, int id) {}

(对应源码:Item.java)

2. 有界缓冲区:ItemQueue

缓冲区是对 JDK BlockingQueue 的一层薄封装,容量固定为 5:

public class ItemQueue {

  private final BlockingQueue<Item> queue;

  public ItemQueue() {
    queue = new LinkedBlockingQueue<>(5);
  }

  public void put(Item item) throws InterruptedException {
    queue.put(item);
  }

  public Item take() throws InterruptedException {
    return queue.take();
  }
}

(对应源码:ItemQueue.java)

这里选用 LinkedBlockingQueue<>(5) 是关键设计决策,它天然具备两方面的并发安全能力:

  • put(item) 在队列满时阻塞:当缓冲区已满(达到容量 5)时,生产者线程会自动挂起,直到有消费者取走元素腾出空间,从而避免缓冲区溢出;
  • take() 在队列为空时阻塞:当缓冲区为空时,消费者线程会自动挂起,直到有生产者放入新元素,从而避免空转与下溢。

正是这两个阻塞语义,替代了传统模式下需要手写的 wait()/notifyAll() 同步逻辑,让模式实现既简洁又线程安全。

3. 生产者:Producer

Producer 每次调用 produce() 就构造一个 Item 放入队列,随后随机休眠 0~1999 毫秒来模拟不稳定的生产速度:

public class Producer {

  private static final SecureRandom RANDOM = new SecureRandom();
  private final ItemQueue queue;
  private final String name;
  private int itemId;

  public Producer(String name, ItemQueue queue) {
    this.name = name;
    this.queue = queue;
  }

  public void produce() throws InterruptedException {

    var item = new Item(name, itemId++);
    queue.put(item);
    Thread.sleep(RANDOM.nextInt(2000));
  }
}

(对应源码:Producer.java)

注意两点实现细节:

  • itemId 是实例级自增字段,由产生 Item 的线程持有,因此不存在跨线程共享的竞态问题;
  • 使用 SecureRandom 而非普通 Random,这是仓库在安全随机数上的统一偏好;实际业务中可按需替换为 ThreadLocalRandom 以提升性能。

4. 消费者:Consumer

Consumer 的职责非常单一:从队列取出 Item 并打印消费日志:

@Slf4j
public class Consumer {

  private final ItemQueue queue;
  private final String name;

  public Consumer(String name, ItemQueue queue) {
    this.name = name;
    this.queue = queue;
  }

  public void consume() throws InterruptedException {
    var item = queue.take();
    LOGGER.info("Consumer [{}] consume item [{}] produced by [{}]", name,
        item.getId(), item.getProducer());

  }
}

(对应源码:Consumer.java;@Slf4j 为 Lombok 注解,由 pom.xml 中的 slf4j-api + logback-classic 依赖提供日志能力)

5. 装配整个流水线:App 入口

App.main 负责把生产者与消费者组装起来:创建 1 个共享 ItemQueue、2 个生产者线程与 3 个消费者线程,全部提交到容量为 5 的固定线程池中无限循环运行:

public static void main(String[] args) {

  var queue = new ItemQueue();

  var executorService = Executors.newFixedThreadPool(5);
  for (var i = 0; i < 2; i++) {

      final var producer = new Producer("Producer_" + i, queue);
      executorService.submit(() -> {
          while (true) {
              producer.produce();
          }
      });
  }

  for (var i = 0; i < 3; i++) {
      final var consumer = new Consumer("Consumer_" + i, queue);
      executorService.submit(() -> {
          while (true) {
              consumer.consume();
          }
      });
  }

  executorService.shutdown();
  try {
      executorService.awaitTermination(10, TimeUnit.SECONDS);
      executorService.shutdownNow();
  } catch (InterruptedException e) {
      LOGGER.error("Error waiting for ExecutorService shutdown");
  }
}

(对应源码:App.java)

这段入口代码有几点值得深入理解:

  • 线程池容量取 5,与缓冲区容量 5 一致,恰好容纳全部 5 个任务(2 生产者 + 3 消费者);
  • 每个任务体都是 while (true) 死循环,生产/消费会持续进行,直到主线程调用 shutdownNow() 强制中断;
  • 主线程通过 awaitTermination(10, TimeUnit.SECONDS) 等待 10 秒后调用 shutdownNow() 结束运行——这也解释了为什么下面的程序输出大约覆盖 10 秒窗口;
  • 该模块的 pom.xml 通过 maven-assembly-plugin 将 com.iluwatar.producer.consumer.App 声明为可执行主类。

6. 运行方式与程序输出

在仓库根目录执行以下命令即可运行并观察生产-消费过程(仓库根 pom.xml 为聚合工程,producer-consumer 是其子模块):

# 编译并运行(在仓库根目录执行)
./mvnw -pl producer-consumer compile exec:java -Dexec.mainClass=com.iluwatar.producer.consumer.App

或者直接执行已打包的 jar:

./mvnw -pl producer-consumer package
java -jar producer-consumer/target/producer-consumer-*.jar

运行后日志输出形如下方(每次运行因随机休眠而略有差异),可以观察到:多个消费者线程从不同生产者生产的 item 中交叉消费,pool-1-thread-N 标识线程池中不同的工作线程:

08:10:08.008 [pool-1-thread-3] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_0] consume item [0] produced by [Producer_1]
08:10:08.008 [pool-1-thread-4] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_1] consume item [0] produced by [Producer_0]
08:10:08.517 [pool-1-thread-5] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_2] consume item [1] produced by [Producer_0]
08:10:08.952 [pool-1-thread-3] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_0] consume item [1] produced by [Producer_1]
08:10:09.208 [pool-1-thread-4] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_1] consume item [2] produced by [Producer_0]
08:10:09.354 [pool-1-thread-5] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_2] consume item [2] produced by [Producer_1]
08:10:10.214 [pool-1-thread-3] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_0] consume item [3] produced by [Producer_1]
08:10:10.585 [pool-1-thread-4] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_1] consume item [3] produced by [Producer_0]
08:10:11.530 [pool-1-thread-5] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_2] consume item [4] produced by [Producer_1]
08:10:11.682 [pool-1-thread-3] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_0] consume item [4] produced by [Producer_0]
08:10:11.781 [pool-1-thread-4] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_1] consume item [5] produced by [Producer_0]
08:10:12.209 [pool-1-thread-5] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_2] consume item [5] produced by [Producer_1]
08:10:13.045 [pool-1-thread-3] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_0] consume item [6] produced by [Producer_0]
08:10:13.861 [pool-1-thread-4] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_1] consume item [6] produced by [Producer_1]
08:10:14.739 [pool-1-thread-5] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_2] consume item [7] produced by [Producer_1]
08:10:14.842 [pool-1-thread-3] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_0] consume item [7] produced by [Producer_0]
08:10:15.975 [pool-1-thread-4] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_1] consume item [8] produced by [Producer_0]
08:10:16.378 [pool-1-thread-5] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_2] consume item [8] produced by [Producer_1]
08:10:16.967 [pool-1-thread-3] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_0] consume item [9] produced by [Producer_0]
08:10:17.417 [pool-1-thread-4] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_1] consume item [9] produced by [Producer_1]
08:10:17.483 [pool-1-thread-5] INFO com.iluwatar.producer.consumer.Consumer -- Consumer [Consumer_2] consume item [10] produced by [Producer_1]

从输出可以验证两个关键行为:其一,Consumer_0/1/2 三个消费者交叉消费,说明多消费者可并发消费;其二,同一个 Producer 生产的 item 序号递增(如 Producer_0 依次产出 item 0、1、2、3…),且不同消费者的消费顺序不同,体现了队列交接的线程安全与无锁竞争假设。

7. 时序交互

Producer-Consumer 时序图

时序图展示了生产与消费的完整交互过程:Producer 通过 ItemQueue.put() 将 Item 送入 LinkedBlockingQueue,Consumer 通过 ItemQueue.take() 取出并消费。当队列满/空时,BlockingQueue 内部的锁与条件变量会自动阻塞调用线程,实现生产速率与消费速率的自动匹配。

适用性:何时使用该模式

以下场景适合引入生产者-消费者模式(英文原文 README 明确列出):

  • 需要管理缓冲区或队列:在多线程环境中,生产者向队列添加数据、消费者从队列取出数据;
  • 需要解耦数据生产与消费:解耦有助于改善应用的设计、性能或可维护性;
  • 需要同步访问共享资源/数据结构:多个线程需要以受控、安全的方式操作同一份共享数据。

此外,从本模块的定位(中文文档将其归类为 Reactive 类并发模式,localization/zh/producer-consumer/README.md)可以看出,它还常用于反应式/异步数据流的背压场景——当生产速度超过消费速度时,有界缓冲区充当天然的背压调节器。

现实世界中的典型应用

该模式在真实系统中无处不在,典型的落地场景包括:

  • 线程池:工作线程作为消费者,处理由其他线程(生产者)提交的任务——本示例的 ExecutorService 本身就是这种结构的缩影;
  • 日志框架:应用各模块产生日志消息(生产),后台日志服务集中消费并落盘/上报;
  • 分布式系统中的消息队列:服务之间通过消息队列进行异步通信,实现削峰填谷与解耦。

收益与代价

收益(Benefits)

  • 解耦(Decoupling):生产者与消费者可独立运行,大幅简化系统设计;
  • 性能提升(Improved Performance):允许多个生产者线程与多个消费者线程并发工作,提高整体吞吐量;
  • 灵活性(Flexibility):在不显著改动既有系统的前提下,可以轻松增加更多的生产者或消费者。

代价(Trade-offs)

  • 复杂性(Complexity):需要谨慎处理同步问题以及潜在的死锁风险;
  • 资源管理(Resource Management):必须合理设置缓冲区大小,避免溢出(overflow)或下溢(underflow)条件——在本示例中,LinkedBlockingQueue<>(5) 的容量即是一个需要按业务吞吐量权衡的调参点。

源码级验证:测试如何保障正确性

仓库为该模块提供了三层单元测试,用于验证模式各参与者的行为:

  • ProducerTest.java:使用 Mockito mock 掉 ItemQueue,断言 produce() 会向队列 put 一个 Item,并以 6 秒超时保护(因为 produce() 内部有最多约 2 秒的随机休眠)验证该方法不会挂死;
  • ConsumerTest.java:先向真实 ItemQueue 预置 5 个 Item,再断言 consume() 恰好调用 take() 5 次,验证消费逻辑与有界队列的交互;
  • AppTest.java:直接执行 App.main,断言整个多线程流水线能无异常启动并运行。

在仓库根目录执行 ./mvnw -pl producer-consumer test 即可运行这些测试。

与其他模式的关系

  • Observer(观察者):两者都涉及事件/数据的通知与处理,但 Observer 侧重于事件订阅与通知机制,而 Producer-Consumer 聚焦于解耦的数据生产与消费;
  • Thread Pool(线程池):采用类似的解耦思路——任务被生产出来,再由工作线程池消费执行。

小结

Producer-Consumer 模式是 Java 并发编程的基石之一。java-design-patterns 仓库中的 producer-consumer 模块用不到百行代码,就完整示范了"有界缓冲区 + 阻塞队列 + 多生产者/多消费者"的标准范式:Item 定义数据单元、ItemQueue 提供线程安全的交接通道、Producer 与 Consumer 以不同速率并行运转,并由 BlockingQueue 的阻塞语义自动完成流量控制。掌握这一模式,你便拥有了构建日志管道、任务队列、消息中间件等各类异步系统的核心骨架。

登录后查看全文
java-design-patterns