JUC详解2——生产者消费者

最新推荐文章于 2024-07-12 09:30:00 发布
原创 最新推荐文章于 2024-07-12 09:30:00 发布 · 382 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#多线程 #并发编程 #多进程 #thread #java

本文详细探讨了生产者消费者问题的两种解决方案，分别是使用synchronized关键字和ReentrantLock配合Condition。通过实例展示了如何确保线程按顺序执行，并处理多线程下的并发控制。面试高频题部分讲解了如何在一个主线程和三个子线程中同步执行。

JUC详解2

生产者消费者

线程间的通信问题——生产者消费者问题
一个简单的生产者消费者模型（使用synchronized）

使用synchronized方法解决
package com.fly.juc.pc;

/**
 * @Description 生产者、消费者
 * 线程间通信问题————生产者、消费者问题：等待唤醒；通知唤醒
 * 线程交替执行：P：生产者、C：消费者, 操作同一个变量
 * P：+1
 * C：-1
 * @ClassName ProCon
 * @Author cai feifei
 * @date 2020.10.23 20:56
 * @Version
 */
public class ProCon {
    public static void main(String[] args) {
        PC pc = new PC();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    pc.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"P").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    pc.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
    }
}

class PC{
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        if (number!=0){
            //等待
            this.wait();
        }
        //业务
        number++;
        System.out.println(Thread.currentThread().getName()+"===="+number);
        //通知
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        if (number==0){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"===="+number);
        this.notifyAll();
    }
}

整齐的输出：
在这里插入图片描述
当存在多个生产者和消费者的时候
在这里插入图片描述
源码中的说明
在这里插入图片描述
这种线程的虚假唤醒，可以使用while来做判断等待

class PC{
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        while (number!=0){
            //等待
            this.wait();
        }
        //业务
        number++;
        System.out.println(Thread.currentThread().getName()+"===="+number);
        //通知
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        while (number==0){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"===="+number);
        this.notifyAll();
    }
}
使用lock解决生产者消费者问题
package com.fly.juc.pc;

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

/**
 * @Description 生产者、消费者
 * 线程间通信问题————生产者、消费者问题：等待唤醒；通知唤醒
 * 线程交替执行：P：生产者、C：消费者, 操作同一个变量
 * P：+1
 * C：-1
 * @ClassName ProCon
 * @Author cai feifei
 * @date 2020.10.23 20:56
 * @Version
 */
public class ProConJuc {
    public static void main(String[] args) {
        PCJ pc = new PCJ();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    pc.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"P1").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    pc.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C1").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    pc.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"P2").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    pc.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C2").start();
    }
}

class PCJ {
    private int number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while (number != 0) {
                //等待
                condition.await();
            }
            //业务
            number++;
            System.out.println(Thread.currentThread().getName() + "====" + number);
            //通知
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number != 0) {
                //等待
                condition.await();
            }
            //业务
            number--;
            System.out.println(Thread.currentThread().getName() + "====" + number);
            //通知
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

在这里插入图片描述
生产者和消费者随机执行，

	如何精准唤醒和通知线程，从而按照自己的意愿进行执行
	Condition：同步监视器
	使用Condition实现指定唤醒功能

package com.fly.juc.pc;

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

/**
 * @Description 一把锁实现流水线
 * @ClassName ProConJuc 
 * @Author cai feifei
 * @date 2020.10.23 20:56
 * @Version
 */
public class ProConJuc {
    public static void main(String[] args) {
        PCJ pc = new PCJ();
        new Thread(()->{for (int i=0;i<10;i++){pc.partA();}},"A").start();
        new Thread(()->{for (int i=0;i<10;i++){pc.partB();}},"B").start();
        new Thread(()->{for (int i=0;i<10;i++){pc.partC();}},"C").start();

    }
}

class PCJ {
    private int number = 0;

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

    public void partA(){
        lock.lock();
        try {
            //业务：判断等待-》执行-》通知
            while (number!=0){
                condition1.await();
            }
            //业务
            System.out.println(Thread.currentThread().getName()+"线程执行了========"+number);
            //唤醒，指定唤醒:condition2=>B
            number=1;
            condition2.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void partB(){
        lock.lock();
        try {
            //业务：判断等待-》执行-》通知
            while (number!=1){
                condition2.await();
            }
            //业务
            System.out.println(Thread.currentThread().getName()+"线程执行了========"+number);
            //唤醒，指定唤醒:condition3=>C
            number=2;
            condition3.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void partC(){
        lock.lock();
        try {
            //业务：判断等待-》执行-》通知
            while (number!=2){
                condition3.await();
            }
            //业务
            System.out.println(Thread.currentThread().getName()+"线程执行了========"+number);
            //唤醒，指定唤醒:condition1=>A
            number=0;
            condition1.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

程序有序依次执行
在这里插入图片描述

高频面试题：一个主线程三个子线程，如何让三个子线程执行结束再执行主线程

package com.fly.juc.pc;

/**
 * @Description 一个主线程三个子线程，如何让三个子线程执行结束再执行主线程
 * @ClassName JoinTest
 * @Author cai feifei
 * @date 2020.10.24 08:50
 * @Version
 */
public class JoinTest {
    public static void main(String[] args) {
        Data data = new Data();

        try {
            Thread thread1 = new Thread(()->{data.test();},"A");
            Thread thread2 = new Thread(()->{data.test();},"B");
            Thread thread3 = new Thread(()->{data.test();},"C");
            thread1.start();
            thread2.start();
            thread3.start();
            //让三个线程执行完，如果在调用start方法后面直接调用join方法，那么三个线程将串行
            thread1.join();
            thread2.join();
            thread3.join();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("主线程执行");
    }
}

class Data{
    public void test(){
        System.out.println(Thread.currentThread().getName()+"线程执行了");
    }
}

上一篇：JUC详解1

下一篇：JUC详解3——8锁问题

Java并发编程（24）—— JUC并发编程类库详解
shangjg3的博客
09-03 365
CyclicBarrier 是一个同步辅助类，用于让一组线程到达一个屏障（barrier）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。这意味着在修改操作发生时，会创建一个新的数组，并将现有的所有元素复制到新数组中，然后在新数组上进行修改。这意味着在修改操作发生时，会创建一个新的数组，然后将现有的所有元素复制到新数组中，并在新数组上进行修改。当一个线程到达交换点时，它会调用 exchange() 方法，该方法会尝试将该线程的数据与另一个线程的数据交换。
JUC核心解析系列(四)——同步工具类 (Synchronizers)深度解析
最新发布
weixin_42148384的博客
06-14 934
在多线程开发中，死锁、资源竞争、线程协调等问题如同暗礁，稍有不慎就会导致程序崩溃。而JUC同步工具类正是解决这些问题的瑞士军刀！
JUC --- 生产者与消费者
fairy767190的博客
08-04 228
这次我们讲解的是一个例题：题目：两个线程操作一个变量，实现两个线程对同一个资源一个进行加1操作，另外一个进行减1操作，且需要交替实现，变量的初始值为0。即两个线程对同一个资源进行加一减一交替操作。 首先我们先定义操作的资源，并且定义方法。 //资源类 class Resource { private int number = 0; public synchronized void up() throws InterruptedException { //1.判断
多线程之生产者与消费者问题
m0_49562228的博客
09-02 556
1.问题概述 生产者消费者问题（Producer-consumer problem），也称有限缓冲问题（Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。 2.解决方案 要解决该
【JUC】生产者消费者问题（包含虚假唤醒问题）
Elephant_King的博客
12-30 379
参考文章 【操作系统】生产者消费者问题_liushall-CSDN博客_生产者消费者问题操作系统 概念 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-bufferproblem），是一个多线程同步问题的经典案例。 可以理解为肯德基买炸鸡， 生产者就相当于肯德基的后厨，生产炸鸡并放到前台 消费者就相当于顾客，从前台获得炸鸡 有限的缓冲区就相当于前台的保温柜里...
JUC与生产者消费者
业精于勤荒于嬉 行成于思毁于随
01-20 514
前面一篇文章介绍了生产者消费者模式，这篇来看看JUC包下的哪些类与该模式有关。 生产者消费者模式中有个中间类Channel，对于数据Data起到通道作用，还确保了Producer与Consumer这些线程的协调运行。在前篇文章所举的例子中的Table类担任这个角色，内部是使用数组实现的队列配合synchronized关键字。而在JUC包下提供了BlockingQueue接口及其实现类，它们相当于C...
JUC：生产者消费者模式
weixin_48410604的博客
07-26 329
文章目录虚假唤醒（spurious wakeup）生产者与消费者模板生产者与消费者模式：synchronized 虚假唤醒（spurious wakeup） 当需要条件判断使用wait()方法时，应该使用循环，而不是if，否则就可能会出现虚假唤醒（spurious wakeup）的情况 简单点理解，虚假唤醒就是除了理应被唤醒的线程之外，还另外唤醒了其它的线程，导致的数据的错误 虚假唤醒的原理： 例： public class Test10 { public static void main(Stri
高并发JUC详解
weixin_48958124的博客
08-26 2230
多线程进阶之高并发编程
JUC并发工具类的应用场景详解
qq_45061342的博客
07-12 1184
解决多线程竞争资源的问题，例如多个线程同时对同一个数据库进行写操作，可以使用ReentrantLock保证每次只有一个线程能够写入。实现多线程任务的顺序执行，例如在一个线程执行完某个任务后，再让另一个线程执行任务。实现多线程等待/通知机制，例如在某个线程执行完某个任务后，通知其他线程继续执行任务。限流：Semaphore可以用于限制对共享资源的并发访问数量，以控制系统的流量。资源池：Semaphore可以用于实现资源池，以维护一组有限的共享资源。
并发编程之JUC并发工具类的应用场景详解
2201_75955594的博客
03-23 514
JUC并发工具类详解
生产者&消费者（Lock）
qq_41517711的博客
11-18 287
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class B { public static void main(String[] args) { Data2 data = new Data2(); new Thread(()-&
JUC（生产者消费者模型、Lock&Condition）
m0_63544124的博客
07-12 211
目录1. 信号灯法（Synchronized实现）解决虚假唤醒​编辑2. 信号灯法（Lock实现）2.1 基本实现2.2 Condition精准通知3 管程法 3 管程法
【JUC —— 03 生产者&消费者】
m0_72328778的博客
07-09 541
分别使用和Lock两种方式实现生产者-消费者模式。
【JUC学习】——生产者消费者问题
时光、疏离了记忆づ童话的博客
01-21 384
  生产者消费者问题用于很好的解释线程间通信的问题，大致意思可以解释为如果货架上物品为空，则通知生产者开始生产物品，如果货架上的物品满了，就通知消费者进行消费。在JUC中实现主要是通过synchronized和lock实现，对于synchronized，一般采用wait（等待）和notify（唤醒）进行线程的同步通信。在juc并发包下对应的lock方法为await和signal，同时使用资源监视器Condition来进行精准唤醒。 一、Synchronized（wait和notify） 下面看一下第一版的
JUC学习之生产者消费者案例-Lock-Condition线程通信
dyt443733328的博客
04-19 273
本文是看视频学习笔记，若有错误请指正！生产者消费者案例的lock写法其中涉及到了Condition的用法，简答的介绍一下：1.Condition接口描述了可能会与锁相关的条件变量，这些变量在用法上与使用Object.wait访问的隐式监视器类似，但提供了更强大的功能。需要特别之处的是，单个lock可能会与多个Condition对象关联，为了避免兼容性问题，Condition方法的名称与对应的Obj...
JUC并发编程（四）-生产者和消费者
二总的猫
02-26 379
4、生产者和消费者 线程间默认是无法通信的，所以需要调度线程。 Producer And Consumer，以下代码中简称Pac。 4.1. 生产者消费者编码模型 1、判断 2、干活 3、通知 4.2. 生产者和消费者- synchroinzed 版 4.2.1. synchroinzed 实现的生产者与消费者 package com.interview.concurrent.lock.pro...
JUC编程02：生产者与消费者问题
WADE_AJJD的博客
07-28 218
一、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并发编程基础学习之生产者消费者问题
weixin_45301250的博客
07-25 265
前言： 面试常问：单例模式，排序算法，生产者和消费者问题，死锁问题 解决生产者消费者问题，我们可以使用synchronized或者Lock锁来解决，这就是我们今天所要学习和讨论的问题！ 1.传统的生产者消费者问题 1-1 什么是生产者消费者问题？ 本质上是 线程之间的通信问题 (即等待唤醒和通知唤醒) 例如线程交替执行, A、B操作同一个变量 num=0, A: num+1, B: num+1 1-2 生产者消费者实现步骤 生产者，消费者问题三步走： 判断是否进入等待 执行相关业务 通知其他线
JUC - 多线程之Synchronized和Lock锁；生产者消费者模式（一）
MinggeQingchun的博客
10-17 661
JUC首先，再简单说一下并行、并发；进程、线程。
JUC详解
03-14
除了传统的 `synchronized` 关键字外，JUC 还引入了更加灵活的锁——`ReentrantLock` 和条件队列 `Condition`[^4]。 示例代码展示如何使用显式锁： ```java import java.util.concurrent.locks.Lock; import java....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值