Java 入门指南：Java 并发编程模式 —— 生产者-消费者模式

ZachOn1y2024-09-14 8:04

文章目录

生产者-消费者问题

生产者消费者问题是一个经典的并发编程问题，它涉及到多个线程之间共享资源的同步和互斥访问。

在生产者消费者问题中，有两类线程：生产者和消费者。生产者线程 负责生产产品并将其放入一个共享的缓冲区，而消费者线程从缓冲区中取出产品并进行消费。但是，缓冲区有限，当缓冲区满时，生产者需要等待；当缓冲区空时，消费者需要等待。

解决方案

为了解决生产者消费者问题中的竞态条件和死锁等并发问题，常见的解决方案有以下几种：

  1. 使用互斥锁和条件变量：生产者和消费者共享一个互斥锁和两个条件变量，通过锁保护共享资源的访问，生产者线程在缓冲区满时等待，消费者线程在缓冲区为空时等待，从而实现线程之间的同步。

  2. 使用信号量：使用两个信号量来表示缓冲区的空和满状态，生产者在缓冲区满时等待，消费者在缓冲区为空时等待，通过对信号量的 P（原语）和 V（原语）操作来实现同步和互斥。

  3. 使用阻塞队列：可以使用具备线程安全的阻塞队列作为缓冲区，这样生产者可以直接将产品放入队列，消费者可以直接从队列中取出产品，队列会自动处理线程之间的同步和互斥。

生产者-消费者模式

生产者消费者模式是一种常见的多线程设计模式，用于解决生产者和消费者之间的解耦和同步问题。

在该模式中，生产者负责生产数据并将其放入共享的缓冲区 ，而消费者则负责从缓冲区中取出数据进行消费。通过合理地组织生产者和消费者线程的执行顺序和同步操作，可以有效地平衡生产和消费的速度，避免数据竞争和阻塞问题。

模式的核心问题

生产者-消费者模式的关键在于生产者和消费者之间的协调和同步，以确保以下几点：

  1. 生产者在缓冲区满时需要等待：以避免向缓冲区添加数据导致溢出。
  2. 消费者在缓冲区空时需要等待：以避免尝试从空缓冲区中取出数据。
  3. 生产者向缓冲区添加数据后需要唤醒等待中的消费者线程。
  4. 消费者从缓冲区取出数据后需要唤醒等待中的生产者线程。

基本原理

生产者/消费者 模式的核心在于使用一个共享的队列来存储数据 ，这个队列可以是阻塞队列（BlockingQueue）或者是非阻塞队列（如 LinkedList）。队列的作用是在生产者和消费者之间传递数据，从而实现线程间的解耦。

生产者

生产者线程负责生成数据并将数据放入队列中。生产者的任务通常是数据的采集、计算或者是任何生成数据的操作。生产者在将数据放入队列时，必须确保队列不会溢出。如果队列已满，生产者可能需要等待，直到队列中有空闲的空间。

消费者

消费者线程负责从队列中取出数据并对其进行处理。消费者的任务通常是数据的消费、处理或者是任何使用数据的操作。消费者在从队列中取出数据时，必须确保队列不是空的。如果队列为空，消费者可能需要等待，直到队列中有新的数据可用。

优点

  • 解耦：生产者和消费者之间通过共享队列通信，而不是直接通信，这样就实现了生产者和消费者之间的解耦。生产者不知道也不关心数据会被哪个消费者消费，同样，消费者也不知道数据是由哪个生产者产生的。

  • 通过使用队列，生产者/消费者模式可以平滑负载，即使在短时间内有大量的数据需要处理，队列也可以暂时存储这些数据，防止生产者因为无法立即处理数据而导致的问题。

  • 生产者/消费者模式允许多个生产者和消费者同时工作，提高了系统的并发性。此外，由于队列的存在，生产者和消费者的数量可以灵活调整，以适应不同的工作负载。

实现方式

使用阻塞队列

Java 提供了 BlockingQueue 接口以及其实现类（如 ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue），可以直接用于实现生产者/消费者模式。使用阻塞队列的好处是可以简化线程间的同步逻辑，因为 BlockingQueue 本身提供了线程安全的阻塞方法（如 put() 和 take()）。

示例代码
java 复制代码 
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ProducerConsumerUsingBlockingQueue {
    private static final BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

    public static void main(String[] args) {
        Thread producerThread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                try {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        Thread consumerThread = new Thread(() -> {
            while (true) {
                try {
                    int value = queue.take();
                    System.out.println("Consumed: " + value);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}
使用 wait/notify 机制

如果不使用阻塞队列，可以通过手动实现 wait/notify 机制来控制生产者和消费者之间的同步。这种方式更加灵活，但同时也增加了实现的复杂度。

Java 入门指南：Java 并发编程 ------ Condition 灵活管理线程间的同步

wait()

该方法用来将当前线程置入休眠状态，直到接到通知或被中断为止。

在调用 wait 之前，线程必须获得该对象的监视器锁，即只能在同步方法或同步块中调用 wait 方法。调用 wait 方法之后，当前线程会释放锁。如果调用 wait 方法时，线程并未获取到锁的话，则会抛出 IllegalMonitorStateException 异常。如果再次获取到锁的话，当前线程才能从 wait 方法处成功返回。

notify()

该方法也需要在同步方法或同步块中调用，即在调用前，线程也必须获得该对象的对象级别锁，如果调用 notify 时没有持有适当的锁，也会抛出 IllegalMonitorStateException。

该方法会从 WAITTING 状态的线程中挑选一个进行通知，使得调用 wait 方法的线程从等待队列移入到同步队列中，等待机会再一次获取到锁，从而使得调用 wait 方法的线程能够从 wait 方法处退出。

调用 notify 后，当前线程不会马上释放该对象锁，要等到程序退出同步块后，当前线程才会释放锁。

notifyAll()

该方法与 notify 方法的工作方式相同，重要的一点差异是：notifyAll 会使所有原来在该对象上 wait 线程统统退出 WAITTING 状态，使得他们全部从等待队列中移入到同步队列中去，等待下一次获取到对象监视器锁的机会。

示例代码
java 复制代码 
import java.util.LinkedList;

public class ProducerConsumerUsingWaitNotify {
    private static final LinkedList<Integer> queue = new LinkedList<>();
    private static final int MAX_SIZE = 10;
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread producerThread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                synchronized (lock) {
                    while (queue.size() >= MAX_SIZE) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    queue.add(i);
                    System.out.println("Produced: " + i);
                    lock.notifyAll();
                }
            }
        });

        Thread consumerThread = new Thread(() -> {
            while (true) {
                synchronized (lock) {
                    while (queue.isEmpty()) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    int value = queue.removeFirst();
                    System.out.println("Consumed: " + value);
                    lock.notifyAll();
                }
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}
使用 Exchanger

对于需要成对交换数据的情况，可以使用 Exchanger。Exchanger 允许两个线程交换数据，当一个线程调用 exchange() 方法时，它会等待另一个线程也调用 exchange() 方法，然后两个线程可以交换它们的数据。

示例代码
java 复制代码 
import java.util.concurrent.Exchanger;

public class ProducerConsumerUsingExchanger {
    private static final Exchanger<String> exchanger = new Exchanger<>();

    public static void main(String[] args) {
        Thread producerThread = new Thread(() -> {
            try {
                String value = "Data from Producer";
                String received = exchanger.exchange(value);
                System.out.println("Producer received: " + received);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                String value = "Data from Consumer";
                String received = exchanger.exchange(value);
                System.out.println("Consumer received: " + received);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}

应用场景

生产者/消费者模式可以应用于多种场景，以下是一些常见的应用场景：

  • 在数据流处理系统中，生产者线程负责收集数据，而消费者线程负责处理数据。这种模式非常适合实时数据分析、日志处理等领域。

  • 在图形渲染引擎中，生产者线程负责渲染图像帧，而消费者线程负责显示图像帧。这种模式可以提高渲染速度并减少延迟。

  • 消息队列系统：在消息队列系统中，生产者线程负责发布消息，而消费者线程负责接收消息。这种模式广泛应用于分布式系统中的消息传递。

总结

生产者/消费者模式是一种重要的多线程设计模式，它通过引入共享队列来实现生产者和消费者之间的解耦。这种模式不仅可以提高系统的并发性和灵活性，还可以平滑负载，适用于多种应用场景。通过使用阻塞队列、wait/notify 机制或者 Exchanger，可以方便地实现生产者/消费者模式，并解决多线程环境下数据生产和消费的问题。

相关推荐
向前看-1 小时前
验证码机制
前端·后端
xlsw_1 小时前
java全栈day20--Web后端实战(Mybatis基础2)
java·开发语言·mybatis
神仙别闹2 小时前
基于java的改良版超级玛丽小游戏
java
黄油饼卷咖喱鸡就味增汤拌孜然羊肉炒饭3 小时前
SpringBoot如何实现缓存预热？
java·spring boot·spring·缓存·程序员
暮湫3 小时前
泛型（2）
java
超爱吃士力架3 小时前
邀请逻辑
java·linux·后端
南宫生3 小时前
力扣-图论-17【算法学习day.67】
java·学习·算法·leetcode·图论
转码的小石3 小时前
12/21java基础
java
李小白663 小时前
Spring MVC(上)
java·spring·mvc
GoodStudyAndDayDayUp4 小时前
IDEA能够从mapper跳转到xml的插件
xml·java·intellij-idea
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程