ProducerConsumerDemo

最新推荐文章于 2025-09-01 20:15:46 发布
转载 最新推荐文章于 2025-09-01 20:15:46 发布 · 67 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/softidea/p/4660363.html

本文通过使用Java实现并发的生产者消费者模式，详细解释了如何利用线程同步技术来确保线程间的正确交互，具体包括生产者线程如何向共享缓冲区添加元素，以及消费者线程如何从缓冲区中获取元素。文中还展示了实际运行结果，验证了该实现的有效性和正确性。

 

 

package algorithm;

public class ProducerConsumer {
    public static void main(String[] args) {
        SyncStack ss = new SyncStack();

        new Thread(new Producer(ss, "p1")).start();
        new Thread(new Consumer(ss, "c1")).start();
        new Thread(new Producer(ss, "p2")).start();
        new Thread(new Consumer(ss, "c2")).start();
    }
}

class WoTou {
    private int id;

    public WoTou(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public String toString() {
        return "WT" + getId();
    }
}

class SyncStack {
    private int index = 0;
    private WoTou[] arrWT = new WoTou[6];

    public synchronized void push(WoTou wt) {
        while (index == arrWT.length) {
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        this.notifyAll();
        arrWT[index++] = wt;
    }

    public synchronized WoTou pop() {
        while (index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        this.notifyAll();
        return arrWT[--index];
    }
}

class Producer implements Runnable {
    private SyncStack ss = null;
    private String name;

    public Producer(SyncStack ss, String name) {
        this.ss = ss;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void run() {
        for (int i = 0; i < 60; i++) {
            WoTou wt = new WoTou(i);
            ss.push(wt);
            System.out.println(getName() + "生产" + wt);
            try {
                Thread.sleep((long) (Math.random() * 100));
            } catch (InterruptedException e) {
            }
        }
    }
}

class Consumer implements Runnable {
    private SyncStack ss = null;
    private String name;

    public Consumer(SyncStack ss, String name) {
        this.ss = ss;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void run() {
        for (int i = 0; i < 60; i++) {
            WoTou wt = ss.pop();
            System.out.println(getName() + "消费" + wt);
            try {
                Thread.sleep((long) (Math.random() * 400));
            } catch (InterruptedException e) {
            }
        }
    }
}


Output:

p1生产WT0
p2生产WT0
c1消费WT0
c2消费WT0
p2生产WT1
p1生产WT1
p2生产WT2
p2生产WT3
p2生产WT4
p2生产WT5
c2消费WT5
p2生产WT6
c1消费WT6
p1生产WT2
c2消费WT2
p1生产WT3
c2消费WT3
p2生产WT7
c1消费WT7
p1生产WT4
c2消费WT4
p1生产WT5
c2消费WT5
p2生产WT8
c1消费WT8
p2生产WT9
c1消费WT9
p1生产WT6
p2生产WT10
c2消费WT6
c1消费WT10
p2生产WT11
p2生产WT12
c2消费WT11
c1消费WT12
p2生产WT13
c2消费WT13
p2生产WT14
c1消费WT14
p1生产WT7
c1消费WT7
p2生产WT15
c2消费WT15
p2生产WT16
p2生产WT17
c2消费WT16
c1消费WT17
p2生产WT18
c2消费WT18
p2生产WT19
p2生产WT20
c1消费WT19
c2消费WT20
p2生产WT21
p1生产WT8
c2消费WT21
p2生产WT22
c2消费WT8
c1消费WT22
p1生产WT9
c2消费WT9
p1生产WT10
c1消费WT10
p1生产WT11
c2消费WT11
p2生产WT23
c2消费WT23
p2生产WT24
c1消费WT24
p1生产WT12
c1消费WT12
p2生产WT25
c2消费WT25
p2生产WT26
p2生产WT27
c1消费WT26
c1消费WT27
p1生产WT13
c1消费WT13
p1生产WT14
c2消费WT14
p2生产WT28
c2消费WT28
p2生产WT29
c1消费WT29
p2生产WT30
c2消费WT30
p2生产WT31
p2生产WT32
c1消费WT31
c2消费WT32
p2生产WT33
c1消费WT33
p2生产WT34
c2消费WT34
p2生产WT35
c1消费WT35
p1生产WT15
c1消费WT15
p1生产WT16
p2生产WT36
c2消费WT16
c2消费WT36
p1生产WT17
c2消费WT17
p2生产WT37
c1消费WT37
p1生产WT18
c1消费WT18
p1生产WT19
c2消费WT19
p1生产WT20
c1消费WT20
p1生产WT21
p1生产WT22
c2消费WT21
c1消费WT22
p1生产WT23
c1消费WT23
p1生产WT24
c2消费WT24
p1生产WT25
c2消费WT25
p2生产WT38
p1生产WT26
c2消费WT38
c2消费WT26
p1生产WT27
c2消费WT27
p1生产WT28
c1消费WT28
p1生产WT29
c2消费WT29
p1生产WT30
c2消费WT30
p1生产WT31
c1消费WT31
p1生产WT32
c2消费WT32
p1生产WT33
c1消费WT33
p1生产WT34
p2生产WT39
c2消费WT34
c2消费WT39
p1生产WT35
p1生产WT36
c1消费WT35
p2生产WT40
c2消费WT36
p2生产WT41
c2消费WT40
c2消费WT41
p2生产WT42
c1消费WT42
p2生产WT43
p1生产WT37
c1消费WT43
p1生产WT38
c2消费WT37
c1消费WT38
p2生产WT44
c2消费WT44
p2生产WT45
c1消费WT45
p2生产WT46
c1消费WT46
p2生产WT47
c2消费WT47
p2生产WT48
c1消费WT48
p1生产WT39
c1消费WT39
p2生产WT49
c2消费WT49
p2生产WT50

http://ixhong.iteye.com/blog/2228623

 

转载于:https://www.cnblogs.com/softidea/p/4660363.html

【Android面试八股文】你知道如何实现非阻塞式生产者消费者模式吗？
字节卷动
06-14 480
再转到我们平时开发过程中经常会碰到这样子的场景:某个模块负责产生数据，这些数据由另一个模块来负责处理。产生数据的模块，就称为生产者，而处理数据的模块，就称为消费者。当然如果只抽象出生产者和消费者，还不是正儿八经的生产者消费者模式，还需要一个缓冲区。生产者生产数据到缓冲区消费者从缓冲区拿数据去消费。服务器端经常使用的消息队列设计就是参照生产者消费者模型。
用Java玩转并发编程—— 讲解并发编程中常用的一些技术点
AI天才研究院
10-09 767
并发编程(concurrency programming)是指利用多核或多CPU、微内核等技术实现多个任务在同一个时刻运行的编程范式，它可以有效提升计算机系统资源利用率、缩短执行时间。Java平台提供了对多线程及其相关机制的支持，包括Thread和Runnable接口，以及锁同步机制，通过良好的编程习惯和技巧，我们可以很容易地开发出具有高并发性的并发应用。本文将围绕并发编程中的常用技术进行讲解，如线程创建、线程间通信、同步机制、原子变量类等，力争全面准确地讲解这些技术。
java160110ProducerConsumerDemo
李政的专栏
01-17 262
/**  * 生产者与消费者  * 多个生产者,多个消费者  * 思考:为什么会出现生产两次,消费一次,或者生产一次,消费两次  */ package java160110; /**  * @author LiZheng  *  */ public class ProducerConsumerDemo { /** * @param args */ p
多线程 生产，消费 ProducerConsumerDemo
mhbsoft的博客
12-03 264
ProducerConsumerDemo.java /** * 资源类 */ class ShareData { private int number = 0; private Lock lock = new ReentrantLock(); private Condition condition = lock.newCondition(); public void increment() { lock.lock(); //加锁 //1
java160110ProducerConsumerDemo2
李政的专栏
01-17 310
/**  * jdk1.5中提供多线程的升级解决方案,将同步替换成Lock操作  */ package java160110; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.Reentra
49天精通Java(Day 22)：Java内存模型与并发编程
**My Coding Family**
12-18 838
在多线程编程中，内存的可见性和一致性是两个重要的问题。Java内存模型（Java Memory Model, JMM）定义了在多线程环境下，Java程序中的变量如何在不同线程之间共享，解决了内存可见性和重排序问题。此外，Java并发包（）为开发者提供了丰富的并发工具类，极大地简化了并发编程的复杂性。本文将详细介绍JMM的基本概念、Volatile与Atomic操作的使用，以及并发包中的高级工具，帮助读者更好地掌握并发编程的技巧。
2023ChatGPT整理回答的Java高级工程师面试题
xmt1139057136的专栏
04-02 2064
原子操作（atomic operation）指的是不会被线程调度机制打断、中间不会有其他线程切换的操作。通常所说的原子操作包括读/写简单变量和对同一内存区域的加锁操作。对于一个原子操作，系统在执行过程中不会出现上下文切换，保证了操作在多线程环境下的正确性。在多线程编程中，原子操作是非常重要的。因为如果多个线程同时对同一数据进行操作，可能会导致数据不一致或者丢失等问题。
tech-interview-for-developer：Java面试金典-从基础到高级全解析
gitblog_00556的博客
09-01 536
在当今软件开发领域，Java依然是企业级应用开发的主流语言。据统计，全球有超过90%的财富500强公司使用Java作为主要开发语言。掌握Java核心技术不仅是通过技术面试的关键，更是成为优秀开发者的必经之路。 本文将带你系统梳理Java面试的核心知识点，从基础概念到高级特性，从内存模型到并发编程，为你提供一份完整的Java面试备战指南。 ## ???? Java面试知识体系总览 ```merma...
java-day14-多线程
lwycc2333的博客
12-27 169
14.1 同步的练习
米哈游笔试题目-Java方向.docx
03-10
ProducerConsumerDemo demo = new ProducerConsumerDemo(); Thread producerThread = new Thread(demo::produce); Thread consumerThread = new Thread(demo::consume); producerThread.start(); consumer...
Lock、Condition实现简单的生产者消费者模式示例
09-04
首先，我们来看一下`ProducerConsumerDemo`类的核心结构。这个类中有一个`bufferList`列表作为共享资源，即生产者生产的商品和消费者消费的商品都会存储在这里。`bufferSize`变量表示缓冲区的容量。`ReentrantLock`...
根据虹软实现的 人脸检测、追踪、识别、年龄检测、性别检测 的JAVA解决方案
09-11
打开下面链接，直接免费下载资源： https://renmaiwang.cn/s/vxfyv (最新版、最全版本)根据虹软实现的 人脸检测、追踪、识别、年龄检测、性别检测 的JAVA解决方案
matlab YALMIP、GLPK安装资源
09-11
matlab的YALMIP、GLPK安装包，内置YALMIP、GLPK，直接将分别其添加到matlab的toolbox、路径中即可（matlab主页-设置路径-添加并包含子文件夹-YALMIP；matlab主页-设置路径-添加文件夹-github_repo）
【scratch3.0少儿编程-游戏原型-动画-项目源码】打砖块.zip
09-11
资源说明： 1：本资料仅用作交流学习参考，请切勿用于商业用途。 2：一套精品实用scratch3.0少儿编程游戏、动画源码资源，无论是入门练手还是项目复用都超实用，省去重复开发时间，让开发少走弯路！ 更多精品资源请访问 https://blog.youkuaiyun.com/ashyyyy/article/details/146464041
使用 OpenCV 技术实现人脸检测的方法与过程
09-11
打开下面链接，直接免费下载资源： https://renmaiwang.cn/s/o7o7f 运用 OpenCV 这一计算机视觉库来开展人脸检测相关的操作
随你记微信小程序_专为学生群体设计的便捷收支管理工具_提供快速记录日常开销与收入的功能_支持多维度数据可视化分析_帮助用户清晰掌握个人财务状况_培养理性消费习惯_无需下载安装即用即.zip
最新发布
09-11
随你记微信小程序_专为学生群体设计的便捷收支管理工具_提供快速记录日常开销与收入的功能_支持多维度数据可视化分析_帮助用户清晰掌握个人财务状况_培养理性消费习惯_无需下载安装即用即.zip
一个基于PyQt5的实时人脸识别系统，使用MTCNN进行人脸检测和FaceNet进行人脸特征提取，支持人脸注册、识别和管理功能
09-11
打开下面链接，直接免费下载资源： https://renmaiwang.cn/s/2u8a8 (最新版、最全版本)一个基于PyQt5的实时人脸识别系统，使用MTCNN进行人脸检测和FaceNet进行人脸特征提取，支持人脸注册、识别和管理功能。
运用 opencv 与 tensorflow 实现实时人脸检测的方法
09-11
打开下面链接，直接免费下载资源： https://renmaiwang.cn/s/sxvdc 运用 opencv 与 tensorflow 这两种工具来开展实时性的人脸检测工作
锁对象调用线程通信方法
06-26
<think>我们讨论的是在Java中，使用锁对象（Lock）来调用线程通信的方法。在Java中，除了使用synchronized关键字和对象的wait()、notify()、notifyAll()方法进行线程通信外，还可以使用java.util.concurrent.locks包中的Lock和Condition接口来实现更灵活的线程通信。具体来说，Lock替代了synchronized，而Condition替代了对象监视器方法（wait,notify,notifyAll）。Condition接口提供了await()、signal()和signalAll()方法，分别对应于wait()、notify()和notifyAll()。使用Lock和Condition的基本步骤：1.创建一个Lock对象（如ReentrantLock）。2.通过Lock对象获取一个或多个Condition对象。3.在需要等待某个条件的地方，使用Condition的await()方法。4.当条件满足时，使用Condition的signal()或signalAll()方法唤醒等待的线程。下面给出一个例子：生产者-消费者模型。在这个模型中，生产者生产物品，消费者消费物品。当物品队列满时，生产者等待；当物品队列空时，消费者等待。我们使用Lock和Condition来实现线程间的通信。代码示例：</think>### 锁对象调用线程通信方法详解 在Java中，使用锁对象（`Lock`）进行线程通信主要通过`Condition`接口实现，它比`synchronized`的`wait/notify`更灵活。`Condition`提供了`await()`、`signal()`和`signalAll()`方法，支持多条件等待集，适用于复杂的线程协作场景。 #### 示例：生产者-消费者模型 ```java import java.util.LinkedList; import java.util.Queue; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ProducerConsumerDemo { private final Queue<Integer> queue = new LinkedList<>(); private final int maxSize = 5; private final Lock lock = new ReentrantLock(); private final Condition notFull = lock.newCondition(); // 队列未满条件 private final Condition notEmpty = lock.newCondition(); // 队列非空条件 // 生产者方法 public void produce(int value) throws InterruptedException { lock.lock(); // 获取锁 try { // 队列满时等待 while (queue.size() == maxSize) { System.out.println("队列已满，生产者等待"); notFull.await(); // 释放锁并等待 } queue.add(value); System.out.println("生产: " + value); notEmpty.signal(); // 唤醒消费者 } finally { lock.unlock(); // 确保锁释放 } } // 消费者方法 public void consume() throws InterruptedException { lock.lock(); try { // 队列空时等待 while (queue.isEmpty()) { System.out.println("队列为空，消费者等待"); notEmpty.await(); // 释放锁并等待 } int value = queue.remove(); System.out.println("消费: " + value); notFull.signal(); // 唤醒生产者 } finally { lock.unlock(); } } public static void main(String[] args) { ProducerConsumerDemo pc = new ProducerConsumerDemo(); // 生产者线程 new Thread(() -> { for (int i = 0; i < 10; i++) { try { pc.produce(i); Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } }).start(); // 消费者线程 new Thread(() -> { for (int i = 0; i < 10; i++) { try { pc.consume(); Thread.sleep(250); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } }).start(); } } ``` #### 代码解释： 1. **锁与条件变量** - `ReentrantLock` 提供显式锁控制 - 两个`Condition`对象： `notFull`（队列未满时唤醒生产者） `notEmpty`（队列非空时唤醒消费者） 2. **关键方法** - `await()`：释放锁并阻塞，直到被`signal()`唤醒 - `signal()`：唤醒一个等待线程（不保证公平性） - `signalAll()`：唤醒所有等待线程 3. **执行流程** - 生产者检查队列满 → 调用`notFull.await()`挂起 - 消费者取出数据 → 调用`notFull.signal()`唤醒生产者 - 消费者检查队列空 → 调用`notEmpty.await()`挂起 - 生产者添加数据 → 调用`notEmpty.signal()`唤醒消费者 4. **重要细节** - 使用`while`而非`if`检查条件（避免虚假唤醒） - `lock.lock()`/`unlock()`必须放在`try-finally`中确保锁释放 - 条件变量需从同一锁对象创建 #### 对比 synchronized | 特性 | Lock + Condition | synchronized | |--------------------|------------------------|-----------------------| | 多条件等待 | ✅ (多个Condition) | ❌ (单一等待集) | | 公平锁 | ✅ (ReentrantLock可选) | ❌ | | 超时等待 | ✅ (awaitNanos等方法) | ❌ | | 可中断等待 | ✅ | ❌ | #### 最佳实践 1. **避免嵌套锁**：防止死锁 2. **及时解锁**：`finally`块中必须调用`unlock()` 3. **精确唤醒**：为不同条件创建独立`Condition`对象 4. **性能敏感场景**：`Lock`通常比`synchronized`性能更高 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值