生产者消费者问题

最新推荐文章于 2024-06-14 15:02:13 发布
最新推荐文章于 2024-06-14 15:02:13 发布
阅读量83 收藏
点赞数
分类专栏： JUC 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48426115/article/details/127895483
版权

synchronized版

  使用if判断（会出现虚假唤醒）

      只有两个线程的情况

public class SynchronizedPC {
    public static void main(String[] args) {
        Date date = new Date();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    date.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    date.subtract();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

    }
}


//资源类
class Date{
    private int number = 0;

    public synchronized void add() throws InterruptedException {
        if (number!=0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "——>" + number);
        //通知其他线程，我+1完毕了
        this.notifyAll();
    }

    public synchronized void subtract() throws InterruptedException {
        if (number==0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "——>" + number);
        //通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

      多个线程的情况

public class SynchronizedPC {
    public static void main(String[] args) {
        Date date = new Date();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    date.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    date.subtract();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    date.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    date.subtract();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();


    }
}


//资源类
class Date{
    private int number = 0;

    public synchronized void add() throws InterruptedException {
        if (number!=0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "——>" + number);
        //通知其他线程，我+1完毕了
        this.notifyAll();
    }

    public synchronized void subtract() throws InterruptedException {
        if (number==0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "——>" + number);
        //通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

        存在问题：如果是多个线程（可能不会出现上面预期的结果，可能是有2,3出现） ——> 虚假唤醒

  使用while循环

        为解决虚假唤醒问题我们需要将if判断改为while循环

        用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。

        拿两个加法线程A、C来说，比如A先执行，执行时调用了wait方法，那它会等待，此时会释放锁，那么线程C获得锁并且也会执行wait方法，两个加线程一起等待被唤醒。此时减线程中的某一个线程执行完毕并且唤醒了这俩加线程，那么这俩加线程不会一起执行，其中A获取了锁并且加1，执行完毕之后C再执行。如果是if的话，那么A修改完num后，C不会再去判断num的值，直接会给num+1。如果是while的话，A执行完之后，C还会去判断num的值，因此就不会执行。

public class SynchronizedPC {
    public static void main(String[] args) {
        Date date = new Date();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    date.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    date.subtract();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    date.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    date.subtract();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();


    }
}


//资源类
class Date{
    private int number = 0;

    public synchronized void add() throws InterruptedException {
        while (number!=0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "——>" + number);
        //通知其他线程，我+1完毕了
        this.notifyAll();
    }

    public synchronized void subtract() throws InterruptedException {
        while (number==0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "——>" + number);
        //通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

Lock版

        生产者和消费者问题 JUC版本

        通过Lock找到Condition

        代码实现

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockPC {
    public static void main(String[] args) {
        Date2 date = new Date2();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                date.add();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                date.subtract();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                date.add();
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                date.subtract();
            }
        },"D").start();
    }
}



//资源类
class Date2{
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition =lock.newCondition();

    //condition.await();    等待
    //condition.signalAll();    唤醒全部
    public void add(){
        lock.lock();
        try {
            while (number!=0){
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "——>" + number);
            //通知其他线程，我+1完毕了
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void subtract(){
        lock.lock();
        try {
            while (number==0){
                //等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "——>" + number);
            //通知其他线程，我+1完毕了
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

 

Condition实现精准通知唤醒

        可以实现A执行完，调用B，B执行完，调用C，C执行完，调用A的执行顺序

    代码实现

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionTest {
    public static void main(String[] args) {
        //A执行完，调用B，B执行完，调用C，C执行完，调用A
        Date3 date = new Date3();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                date.printA();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                date.printB();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                date.printC();
            }
        },"C").start();
    }
    
}


//资源类 Lock
class Date3{
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    private int number = 1; //A=1,B=2,C=3

    public void printA(){
        lock.lock();
        try {
            while (number!=1){
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "——> AAAAA");
            number = 2;
            //唤醒线程B
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();
        try {
            while (number!=2){
                //等待
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "——> BBBBB");
            number = 3;
            //唤醒线程C
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC(){
        lock.lock();
        try {
            while (number!=3){
                //等待
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "——> CCCCC");
            number = 1;
            //唤醒线程A
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

ABCdxy~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现生产者消费者问题
05-27
C语言实现生产者消费者问题，分配具有n个缓冲区的缓冲池，作为共享资源。 定义两个资源型信号量empty 和full，empty信号量表示当前空的缓冲区数量，full表示当前满的缓冲区数量。 定义互斥信号量mutex，当某个进程...
2021-06-12 lock 锁 与synchronized 锁
pangiggs的博客
06-12 78
//生产者与消费者 public class A { public static void main(String[] args) { Data data = new Data(); new Thread(()->{ for (int i = 0; i < 10; i++) { try { data.increment(); }
java 同步方式 lock_java的两种同步方式， Synchronized与ReentrantLock的区别
weixin_39922868的博客
02-24 187
java在编写多线程程序时，为了保证线程安全，需要对数据同步，经常用到两种同步方式就是Synchronized和重入锁ReentrantLock。相似点：这两种同步方式有很多相似之处，它们都是加锁方式同步，而且都是阻塞式的同步，也就是说当如果一个线程获得了对象锁，进入了同步块，其他访问该同步块的线程都必须阻塞在同步块外面等待，而进行线程阻塞和唤醒的代价是比较高的(操作系统需要在用户态与内核态之间来...
Java实现生产者消费者问题
王梦杰_MengJie
04-26 4698
生产者-消费者问题是计算机科学中经典的同步问题之一，它描述了多个线程在共享数据的情况下如何协同工作。该问题通常涉及到一个共享缓冲区，其中生产者线程生成数据并将其放入缓冲区，而消费者线程从缓冲区中取出数据并对其进行处理。生产者和消费者线程必须协同工作，以避免竞态条件和死锁等问题。以上为通过Java代码实现解决生产消费者问题的实例，通过本实例希望大家能学会如果解决此问题，学会如何数据共享时，各个线程协同工作。
进程调度算法-生产者消费者问题
zhengmmm1999的博客
06-14 2848
@进程调度算法之生产者消费者问题 生产者消费者问题 问题介绍 生产者生产产品，消费者消费产品，两者的资源存储在同一个资源池。 因此，问题来了，生产者生产商品需要在资源池的存储范围内；然而消费者消费的资源需要在资源池不为空的前提下。由于两者均会对资源池造成修改，为了保证统一性，因此，两者需要互斥访问，同时，生产者生产产品需要对生产数量资源进行更改，因此生产者也需要互斥访问。 ProCon.c 代码实...
Java多线程——生产者消费者问题
泯灭于众生，高歌于孤夜！
01-19 5977
创建多个线程去执行不同的任务，如果这些任务之间有着某种关系，那么线程之间必须能够通信来协调完成工作。 生产者消费者问题（英语：Producer-consumer problem）就是典型的多线程同步案例，它也被称为有限缓冲问题（英语：Bounded-buffer problem）。该问题描述了共享固定大小缓冲区的两个线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保
Java多种方式解决生产者消费者问题（十分详细）
热门推荐
爱你の大表哥的博客
08-16 6万+
生产者消费者问题 一、问题描述 生产者消费者问题（Producer-consumer problem），也称有限缓冲问题（Bounded-buffer problem），是一个多线程同步问题的经典案例。生产者生成一定量的数据放到缓冲区中，然后重复此过程；与此同时，消费者也在缓冲区消耗这些数据。生产者和消费者之间必须保持同步，要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区空时消耗...
生产者消费者问题 C++实现
陈浩的博客
06-29 3万+
生产者消费者问题 C++实现 知识准备 thread 介绍 成员类 成员函数 sleep_for 介绍 mutex 介绍 成员函数 unique_lock 介绍 成员函数 codition_variable 介绍 成员函数 代码示例 生产者消费者问题 C++实现 知识准备 thread 介绍 定位于头文件的class thread 表示...
操作系统经典问题之生产者消费者问题
m0_43405302的博客
11-07 9827
一、生产者消费者问题 生产者和消费者问题是计算机同步互斥的经典问题，其意思就是生产者把生产出来的产品放在仓库里，消费者把产品从仓库里取出来。仓库属于临界区，生产者和消费者一次只能一个进入临界区中。两个进程之间就有一个同步互斥问题，下面我将对该问题进行详细介绍。 二、思路分析 对于一个仓库，仓库的容量是有限的，对应的临界资源是有限的，假设仓库的容量是n。当仓库装满了，就不能允许生产者进行访问，如果仓库满了，生产者再把产品放进仓库就会导致仓库爆仓。与此同时，当库存为零时也不能允许消费者进入，这个不符合逻辑。基于
操作系统_生产者消费者问题
&再见萤火虫&的博客
03-17 1万+
目录 1，生产者消费者问题 问题的提出 初步思考 进程资源共享关系和同步关系分析 问题的具体解决 第一搏 存在的问题 第二搏 多维度思考 1，单生产者、单消费者、多缓冲区 2，多生产者、多消费者、单缓冲 3，单生产者、单消费者、单缓冲 4，允许生产者写时，消费者可读 5，缓冲池无限大 6，调整生产者wait顺序 7，调整消费者wait顺序 8，调整wait顺序（...
Linux线程编程之生产者消费者问题
12-14
　本文基于顺序循环队列，给出Linux生产者/消费者问题的多线程示例，并讨论编程时需要注意的事项。文中涉及的代码运行环境如下： 　本文假定读者已具备线程同步的基础知识。 　一 顺序表循环队列 　1.1 ...
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 384
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 555
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 651
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
SpringBoot之请求映射原理
好记性不如烂笔头
06-12 1271
我们发出的请求，SpringMVC是如何精准定位到那个Controller以及具体方法？其实这都是 HandlerMapping 发挥的作用，这篇博文我们以 RequestMappingHandlerMapping 为例并结合源码一步步进行分析。默认 HandlerMapping 主要定义在和其祖父类中获取所有类型是 Object 的 beans，并且 beanName 不以开头根据 beanName 获取 beanType如果 beanType 上存在注解则进行处理。
微型操作系统内核源码详解系列四（3）：操作系统调度算法（FreeRTOS内核篇上）
2301_77061352的博客
06-12 866
-uxTopPriority，被设定为是代表最大优先级的数字，自减操作代表从就绪列表最后一个链表（优先级最高的链表）开始查找，直到找到任务链表不为空的优先级任务，那么这个任务肯定也是所有任务中优先级最大的任务，然后获取这个任务的TCB并更新pxCurrentTCB（切换的具体函数），最后更新uxTopReadyPriority的值。容笔者说一下个人看法，从c语言和数据结构算法的层面学习，只能说是舍本逐末，透过Freertos这个小型系统，窥见庞大的操作系统架构的一角，这才是我们学习的重点。
Invalid keystore format，获取安全码SHA1值出错
yfy1907的博客
06-11 221
Invalid keystore format 错误
生产者消费者问题pv
10-06
生产者消费者问题是指在多线程环境下，生产者和消费者之间共享一个有限的缓冲区，生产者将数据放入缓冲区，而消费者则从缓冲区中取出数据。这个问题的关键在于解决生产者和消费者之间的同步与互斥关系，以避免出现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值