生产者与消费者Synchronized--JUC 两版本----Condition简单使用

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量115 收藏
点赞数
分类专栏： JUC 文章标签： 多线程 java 多进程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44236958/article/details/115941067
版权

生产者与消费者

Synchronized版本

package com.nie.juc.shxf;/*
 *
 *@auth  wenzhao
 *@date 2021/4/20  13:15
 */

/**
 * 生产者消费者
 */

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

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

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


//判断等待 业务通知
class Data {
    //数字资源
    private int number = 0;

    //资源加一   increment增加
    //生产者
    public synchronized void increment() throws InterruptedException {
        if (number != 0) {
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "===>" + number);
        //通知其他等待的线程
        this.notifyAll();
    }

    //资源加一   decrement 递减
    //消费者
    public synchronized void decrement() throws InterruptedException {
        if (number == 0) {
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "===>" + number);
        //通知其他等待的线程
        this.notifyAll();
    }
}

问题存在: 如果abcd 4个线程! 虚假唤醒

虚假唤醒相关解释

在这里插入图片描述

在这里插入图片描述

if改为while判断
package com.nie.juc.shxf;/*
 *
 *@auth  wenzhao
 *@date 2021/4/20  13:15
 */

/**
 * 生产者消费者
 */

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

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

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

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

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


    }
}


//判断等待 业务通知
class Data2 {
    //数字资源
    private int number = 0;

    //资源加一   increment增加
    //生产者
    public synchronized void increment() throws InterruptedException {
        while (number != 0) {
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "===>" + number);
        //通知其他等待的线程
        this.notifyAll();
    }

    //资源加一   decrement 递减
    //消费者
    public synchronized void decrement() throws InterruptedException {
        while (number == 0) {
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "===>" + number);
        //通知其他等待的线程
        this.notifyAll();
    }
}

结果

A===>1
B===>0
A===>1
B===>0
A===>1
B===>0
A===>1
B===>0
A===>1
B===>0
A===>1
C===>0
A===>1
B===>0
A===>1
D===>0
A===>1
C===>0
A===>1
D===>0
A===>1
B===>0
A===>1
D===>0
A===>1
C===>0
A===>1
D===>0

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

在这里插入图片描述

通过Lock找到Condition

在这里插入图片描述

代码实现

package com.nie.juc.shxf;/*
 *
 *@auth  wenzhao
 *@date 2021/4/20  13:15
 */

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

/**
 * 生产者消费者
 */

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

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

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

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

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

    }
}


//判断等待 业务通知
class Data3 {
    //数字资源
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();


    //condition.await();  等待
    //condition.signalAll();;  唤醒全部
    //资源加一   increment增加
    //生产者
    public  void increment() throws InterruptedException {
        lock.lock(); //开启锁
        try {
            while (number != 0) {
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "=增加=>>" + number);
            condition.signalAll();//唤醒其他程序 我生产者已经执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //资源加一   decrement 递减
    //消费者
    public  void decrement() throws InterruptedException {
        lock.lock(); //开启锁
        try {
            while (number == 0) {
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=减少=>>" + number);
            condition.signalAll();//唤醒其他程序 我生产者已经执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

结果

A=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
B=减少=>>0
C=增加=>>1
D=减少=>>0
A=增加=>>1
D=减少=>>0
A=增加=>>1
D=减少=>>0
A=增加=>>1
D=减少=>>0
A=增加=>>1
D=减少=>>0
A=增加=>>1
D=减少=>>0
A=增加=>>1
D=减少=>>0
A=增加=>>1
.....
后续一切正常

补充Condition

condition 精准的通知和唤醒线程

有序的执行ABCD

Reentrant 再进入

ReentrantLock

condition2.await(); 等待 condition1.signal();//唤醒其他人

package com.nie.juc.shxf;/*
 *
 *@auth  wenzhao
 *@date 2021/4/20  13:15
 */
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 有序的打印ABC
 */
public class JUCDemo04Order {
    public static void main(String[] args) {
        Data4 data = new Data4();

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

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

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


//判断等待 业务通知
class Data4 {
    //数字资源
    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    private int number = 1; //1A 2B 3C

    //condition.await();  等待
    //condition.signalAll();;  唤醒全部
    //资源加一   increment增加
    //生产者
    public void print1() throws InterruptedException {
        lock.lock(); //开启锁
        try {


            while (number != 1) {
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() +"AAAAAA");
            number = 2;
            condition2.signal();//唤醒其他人2 号
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    //资源加一   decrement 递减
    //消费者
    public void print2() throws InterruptedException {
        lock.lock(); //开启锁
        try {
            while (number != 2) {
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "BBBBB");
            number=3;
            condition3.signal();//唤醒其他人  3 号
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


    //资源加一   decrement 递减
    //消费者
    public void print3() throws InterruptedException {
        lock.lock(); //开启锁
        try {
            while (number != 3) {
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() +"CCCCC");
            number=1;
            condition1.signal();//唤醒其他人  1 号
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
靠谱的大钊
关注
专栏目录
springboot对条件接口Condition的扩展和使用---2
weixin_42030357的博客
06-15 319
文章目录1：springboot的基础实现类2：@Conditional注解3：SpringBootCondition抽象类4：@ConditionalOnProperty4.1：定义配置类4.2：定义启动类4.3：源码分析 原博文，点击这里 写在前面 对于Condition的基础使用，可以参考这里。 开始学习吧！！！ 1：springboot的基础实现类 类org.springframework.boot.autoconfigure.condition.SpringBootCondition是spring
JUC详解-3-生产者消费者问题（Synchronized&Lock-Condition）
baidu_38126306的博客
11-10 160
JUC详解 -> 生产者消费者问题 面试必问：单例模式、排序算法、生产者消费者问题、死锁 1. Synchronized版生产者消费者问题 /** * 线程之间的通信问题：生产者和消费者问题！ * 线程交替执行 * 线程A、B 操作同一个变量 +1/-1 * 等待唤醒、通知唤醒 */ public class Demo01 { public static void main(String[] args) { Data data = new Data();
JUC - 多线程之Synchronized和Lock锁；生产者消费者模式（一）
MinggeQingchun的博客
10-17 588
JUC首先，再简单说一下并行、并发；进程、线程。
生产者-消费者模型
一江溪水
11-20 7367
什么是生产者消费者模型 生产者 - 消费者模型（ Producer-consumer problem） 是一个非常经典的多线程并发协作的模型，在分布式系统里非常常见。 这个模型由两类线程和一个缓冲区组成来组成 生产者线程：生产数据，并把数据放在这个队列里面 缓冲区：存放生产者的数据的地方 消费者线程：从队列里面取数据，消费数据 运行流程 生产者和消费者在同一时间段内共用同一个存储空间 生产者往存储空间中添加产品 消费者从存储空间中取走产品 当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。
java--JUC快速入门（彻底搞懂JUC）
热门推荐
weixin_43888181的博客
05-08 10万+
java–JUC快速入门（彻底搞懂JUC） 文章目录java--JUC快速入门（彻底搞懂JUC）1、学习多线程之前需要知道的一些概念。2、JUC的结构3、Lock锁(重点)4、集合类不安全5、Callable()6、常用的辅助类7、读写锁8、阻塞队列9、线程池 1、学习多线程之前需要知道的一些概念。 1.1 JUC是什么？ JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！...
JAVA多线程-生产者消费者模型
SIESTA030的博客
01-27 644
生产者消费者模型 一个经典的同步模型。 在Java中要制作这个模型，得满足以下几个条件： 高内聚低耦合前提下，线程操纵资源类。 判断、干活、唤醒通知。 严防多线程并发状态下的虚假唤醒。 传统的：sync、wait、notify JUC变种：lock、await、signal 以上这俩种都不是我们的重点。 下面还是来实现一下。 传统JUC锁版 示例 双线程情况，大于双线程就得加多个 condition class Data { private int number
JUC --- 生产者与消费者
fairy767190的博客
08-04 183
这次我们讲解的是一个例题：题目：两个线程操作一个变量，实现两个线程对同一个资源一个进行加1操作，另外一个进行减1操作，且需要交替实现，变量的初始值为0。即两个线程对同一个资源进行加一减一交替操作。 首先我们先定义操作的资源，并且定义方法。 //资源类 class Resource { private int number = 0; public synchronized void up() throws InterruptedException { //1.判断
JUC-生产者和消费者问题
Watson24的博客
01-12 151
JUC-生产者和消费者问题 生产者和消费者问题 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲
Juc并发编程学习笔记---狂神说（全）
ProGram_Java521的博客
10-31 1592
Juc并发编程学习笔记---狂神说（全）
个人学习-JUC-笔记
02-25
- **BlockingQueue**：阻塞队列，常用于生产者-消费者模型，如ArrayBlockingQueue、LinkedBlockingQueue。 6. **原子类** - **Atomic包**：如AtomicInteger、AtomicLong等，提供原子操作，避免显式锁定。 7. **...
JUC学习 - Condition
TyuIn的博客
11-25 172
一、JUC中的Condition 1、synchronized中等待和唤醒线程示例 public class SyncWaitAndNotifyTest { static Object lock = new Object(); public static class T1 extends Thread { @Override public void run() { System.out.println(System.curre
面试高频-----生产者与消费者经典问题
Gebo的博客
04-29 502
synchronized版本 package cn.gb.demo08; /** * 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒 * 线程交替执行 A B 操作 */ public class A { public static void main(String[] args) { Data data=new Data(); //这...
android开发-Kotlin JAVA 学习十：生产者消费者模式
南七小僧的学海无涯
06-25 208
有多种方法可以实现多线程生产/消费模型（大多也适用于Java）
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 882
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 285
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 489
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1000
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 627
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Java实现操作系统生产者-消费者问题
"操作系统课程设计，使用Java解决生产者-消费者问题，涉及多进程同步，有界缓冲区，线程同步及并发控制" 在操作系统中，生产者-消费者问题是多线程编程中的一个经典同步问题。这个问题模拟了生产者（产生资源）和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值