JUC（3）生产者与消费者问题（线程通信）

最新推荐文章于 2024-06-25 00:14:02 发布
最新推荐文章于 2024-06-25 00:14:02 发布
阅读量207 收藏
点赞数
分类专栏： # 多线程与并发编程 文章标签： 生产者与消费者问题 Condition 条件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang_luwei/article/details/109996430
版权

文章目录

  • 线程之间的通信问题：生产者与消费者问题

一、传统版本，用Synchronized实现的

package com.wlw.producerandconsumer;

/**
 * 线程之间的通信问题：生产者与消费者问题
 * 两个线程交替执行，操作同一变量，一开始为0，A B 一个执行+1  另一个执行-1
 */
public class demo01_synchronized {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

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

//资源类
//写一个生产者与消费者问题，只有三步：1.判断等待、2.业务、3.唤醒通知
class Data{

    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        //1.判断是否需要等待
        if(number != 0){
            this.wait();
        }
        //2.业务
        number++;
        System.out.println(Thread.currentThread().getName()+"==>"+number);
        //3.唤醒通知 ,通知线程我+1完毕了
        this.notifyAll();
    }


    //-1
    public synchronized void decrement() throws InterruptedException {
        //1.判断是否需要等待
        if(number == 0){
            this.wait();
        }
        //2.业务
        number--;
        System.out.println(Thread.currentThread().getName()+"==>"+number);
        //3.唤醒通知 ,通知线程我-1完毕了
        this.notifyAll();
    }
}

1.1存在的问题(虚假唤醒)，线程不只两个时

  • 上面的案例中只有两个线程，不会出现问题，假如有四个线程就会出现问题 （虚假唤醒问题）

  • 造成虚假唤醒的根本原因是notify唤醒线程和被唤醒的线程获取锁不是原子操作。在线程被唤醒过程中，如果锁被其他线程抢占执行，等持锁线程执行完后，被唤醒线程获得锁执行，就有可能造成临界资源为0的情况下被过度消费为负数的现象（在生产者消费者模式中）。

  • whlie循环在wait后再进行一次临界资源的判断，如果临界资源不满足要求继续设置线程为等待状态，避免了以上过度消费的问题出现。

    在这里插入图片描述

  • 虚假唤醒问题解决：将if 换成 while 判断 （if只会判断一次，while会一直判断）

package com.wlw.producerandconsumer;

/**
 * 线程之间的通信问题：生产者与消费者问题
 * 四个线程
 */
public class demo01_synchronized{
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

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

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

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

//资源类
//写一个生产者与消费者问题，只有三步：1.判断等待、2.业务、3.唤醒通知
class Data{

    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        //1.判断是否需要等待
        while (number != 0){
            this.wait();
        }
        //2.业务
        number++;
        System.out.println(Thread.currentThread().getName()+"==>"+number);
        //3.唤醒通知 ,通知线程我+1完毕了
        this.notifyAll();
    }


    //-1
    public synchronized void decrement() throws InterruptedException {
        //1.判断是否需要等待
        while (number == 0){
            this.wait();
        }
        //2.业务
        number--;
        System.out.println(Thread.currentThread().getName()+"==>"+number);
        //3.唤醒通知 ,通知线程我-1完毕了
        this.notifyAll();
    }
}

二、juc版（lock锁）的生产者与消费者问题

  • 对比一下Synchronized，它有三个关键点：Synchronized加锁，wait等待，notify（notifyAll）唤醒，而juc版的三个关键点：lock加锁，await等待，signal（signalAll）唤醒 （jdk帮助文档中写道：在Lock取代synchronized方法和语句的使用，一个Condition取代对象 监视器的使用方法。）

    在这里插入图片描述

  • await与，signal（signalAll）的使用要通过Condition，而Contidion是通过lock锁来获取的 （方法为：newContidion() 返回一个新的Condition实例绑定到该Lock实例。）

    在这里插入图片描述

  • 生产者与消费者 代码

package com.wlw.producerandconsumer;

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


public class demo02_Lock {
    public static void main(String[] args) {
        Data2 data = new Data2();

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

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

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

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        },"D").start();
    }
}

//资源类
//写一个生产者与消费者问题，只有三步：1.判断等待、2.业务、3.唤醒通知
class Data2{

    private int number = 0;

    Lock lock = new ReentrantLock(); //创建锁
    Condition condition = lock.newCondition();//返回一个新的Condition实例绑定到该Lock实例。

    //+1
    public void increment(){
        lock.lock();//加锁

        try {
            //1.判断是否需要等待
            while (number != 0){
                condition.await();
            }
            //2.业务
            number++;
            System.out.println(Thread.currentThread().getName()+"==>"+number);
            //3.唤醒通知 ,通知线程我+1完毕了
            condition.signalAll(); //全部唤醒
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); //解锁
        }
    }


    //-1
    public void decrement() {
        lock.lock();

        try {
            //1.判断是否需要等待
            while (number == 0){
                condition.await();
            }
            //2.业务
            number--;
            System.out.println(Thread.currentThread().getName()+"==>"+number);
            //3.唤醒通知 ,通知线程我-1完毕了
           condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

三、Condition 条件 有什么用呢？

  • 任何一个新的技术，绝对不仅仅只是覆盖了原来的技术，它一定有着自己的优势与补充
  • Condition的优势：精准的通知和唤醒
package com.wlw.producerandconsumer;

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

/**
 * Condition 实现精准的通知和唤醒线程！
 * A执行完调用B B行完调用C  C执行完调用A
 */
public class demo03_Condition {
    public static void main(String[] args) {
        Data3 data3 = new Data3();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printC();
            }
        },"C").start();

    }
}

class Data3{

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    private int number = 1; //number = 1时执行A，2B  3C

    public void printA(){
        lock.lock();
        try {
            // 判断等待，业务，唤醒
            while(number != 1){
                condition1.await(); //等待
            }
            System.out.println(Thread.currentThread().getName()+"==>AAAAAAAAAAAA"); //业务
            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()+"==>BBBBBBBB"); //业务
            number = 3;
            // 唤醒指定的人（线程）B
            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()+"==>CCCCCCC"); //业务
            number = 1;
            // 唤醒指定的人（线程）B
            condition1.signal();//唤醒
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

}
悬浮海
关注
专栏目录
JUC编程02：生产者与消费者问题
WADE_AJJD的博客
07-28 158
一、Synchronized解决方案 代码演示 package com.haust.pc; /** * 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒 * 线程交替执行 A B 操作同一个变量 num = 0 * A num+1 * B num-1 */ public class A { public static void main(String[] args) { Data data = new Data(); new Th
JUC生产者消费者问题
qq_42388853的博客
12-25 125
juc版本和synchronized版本的区别： juc这里使用锁需要事先在类里面声明锁，然后用锁获取newCondition，使用condition类即可，以下是jdk，api里面写的 例如，假设我们有一个有限的缓冲区，它支持put和take方法。 如果在一个空的缓冲区尝试一个take ，则线程将阻塞直到一个项目可用; 如果put试图在一个完整的缓冲区，那么线程将阻塞，直到空间变得可用。 我们希望在单独的等待集中等待put线程和take线程，以便我们可以在缓冲区中的项目或空间可用的时候使用仅通知单个线程
【JUC基础】06. 生产者和消费者问题
有一只柴犬的专栏
05-15 860
学习JUC，就不得不提生产者消费者。生产者消费者模型是一种经典的多线程模型，用于解决生产者和消费者之间的数据交换问题。在生产者消费者模型中，生产者生产数据放入共享的缓冲区中，消费者从缓冲区中取出数据进行消费。在这个过程中，生产者和消费者之间需要保持同步，以避免数据出现错误或重复。今天我们就来说说生产者消费者模型，以及JUC中如何解决该模型的同步问题。
3、JUC：生产者和消费者问题
cxycxytony的博客
10-30 111
3.1、Sychronized版 package com.chen.pc; /** * 线程交替的通信问题，生产者和消费者问题! 等待唤醒，通知唤醒 * 线程交替执行 A B 操作同一个变量 num = 0 * A num + 1 * B num - 1 */ public class A { public static void main(String[] args) { Data data = new Data(); new Thread(()-&gt
生产者和消费者问题[线程通信]
繁星呀
03-09 171
生产者和消费者问题 生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，如下图所示，生产者向空间里存放数据，而消费者取用数据，如果不加以协调可能会出现以下情况： 存储空间已满，而生产者占用着它，消费者等着生产者让出空间从而去除产品，生产者等着消费者消费产品，从而向空间中添加产品。互相等待，从而发生死锁。 传统解决方案 (synchronized,wait,notifyAll) /** * 资源类 */ class Data { /** *
JUC学习之生产者消费者案例-Lock-Condition线程通信
dyt443733328的博客
04-19 228
本文是看视频学习笔记，若有错误请指正！生产者消费者案例的lock写法其中涉及到了Condition的用法，简答的介绍一下：1.Condition接口描述了可能会与锁相关的条件变量，这些变量在用法上与使用Object.wait访问的隐式监视器类似，但提供了更强大的功能。需要特别之处的是，单个lock可能会与多个Condition对象关联，为了避免兼容性问题，Condition方法的名称与对应的Obj...
JUC详解-3-生产者消费者问题（Synchronized&Lock-Condition）
baidu_38126306的博客
11-10 158
JUC详解 -> 生产者消费者问题 面试必问：单例模式、排序算法、生产者消费者问题、死锁 1. Synchronized版生产者消费者问题 /** * 线程之间的通信问题：生产者和消费者问题！ * 线程交替执行 * 线程A、B 操作同一个变量 +1/-1 * 等待唤醒、通知唤醒 */ public class Demo01 { public static void main(String[] args) { Data data = new Data();
JUC之生产者与消费者问题
OriSu
05-20 325
一、简介 生产者与消费者问题主要是涉及到线程间通信的问题，以一个简单案例为例，初始没有产品，生产者生产了产品，就要消费者去消费，消费者消费完再让生产者继续生产 二、Synchronized版本 package P_C.Synchronized; public class TestPC { public static void main(String[] args) { Data data = new Data(); new Thread(()->{
JUC_生产者消费者问题
我认不到你的博客
09-20 163
生产者消费者问题（Producer-consumer problem），也称有限缓冲问题（Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。
JUC+课程源码+线程操作
09-04
当队列空时，消费者线程会被阻塞。它是并发编程中的重要工具，常用于线程间的通信和数据共享，如`ArrayBlockingQueue`、`LinkedBlockingQueue`和`PriorityBlockingQueue`等。 在`juc_atguigu`这个压缩包中，包含了...
面试高频-----生产者与消费者经典问题
Gebo的博客
04-29 500
synchronized版本 package cn.gb.demo08; /** * 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒 * 线程交替执行 A B 操作 */ public class A { public static void main(String[] args) { Data data=new Data(); //这...
多线程--生产者和消费者问题
weixin_45990304的博客
04-12 437
问题:多线程中有一个比较经典的案例就是生产者和消费者问题.共同操作同一个资源,就是生成的产品,一个生产一个消费,这就必须考虑到线程的安全同步.如何实现多线程中的线程安全,保证资源的统一. 在生产者和消费者问题中,生产者和消费者都是多线程操作. 这里有一个执行生产者和消费者动作的对象,需要对产品有一个判断,判断何时进行生产何时进行消费 /**操作数据*/ class Product{ int num;//产品的数量 //让生产者生产,数量小于20就开始生产 public synchr
android开发-Kotlin JAVA 学习十：生产者消费者模式
南七小僧的学海无涯
06-25 206
有多种方法可以实现多线程生产/消费模型（大多也适用于Java）
JUC 多线程
m0_46499246的博客
03-30 247
JUC 多线程介绍 1、 线程的生命周期 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread(); 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行； 运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状
AXMLPrinter，xml逆向工具
最新发布
09-22
AXMLPrinter，xml逆向工具
虚拟机DirectX组建在线安装
09-22
虚拟机DirectX组建在线安装，有需要的试试
变压器变频器配电柜电路控制原理图CAD施工图纸设备控制图加料机电气控制图
09-22
变压器变频器配电柜电路控制原理图CAD施工图纸设备控制图加料机电气控制图
2024年夏威夷果行业分析报告.pptx
09-22
行业报告
Java JUC并发编程实例：守护线程与Synchronized锁
这个资源通过具体的代码实例，展示了Java多线程编程中的基础概念，包括如何使用用户线程和守护线程，以及如何利用JUC库中的同步机制（如`synchronized`和`Lock`）来处理并发场景中的数据一致性问题。这些知识对于有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悬浮海

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值