生产者与消费者问题？

已于 2022-03-19 15:49:51 修改
阅读量247 收藏
点赞数
分类专栏： 并发编程 文章标签： JUC
于 2022-03-19 15:47:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42575310/article/details/123595587
版权

生产者消费者模式是并发、多线程编程中经典的设计模式。

        简单来看，就是一个类负责生产，一个类负责消费。举例来说，一个变量，生产者不断增加这个变量，消费者不断减少这个变量。在互联网应用中，抢票机制就是应用了该模式，比如大麦网演唱会门票抢票，12306火车票抢票等。

1、生产者与消费者问题 synchronized 版本

 假设有两个线程A和B，操作同一个变量，A线程+1，B线程-1， 交替循环进行

package cn.dczh.juc;

/**
 * @ClassName: A
 * @description: A线程 B线程 操作同一个变量 num= 0  A:+1   B:-1
 * @author: 
 * @date: 2022/3/16 21:34
 * @version: 1.0
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();

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

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

class Data {

    private int num = 0;

    public synchronized void incr() throws InterruptedException {
        if (num != 0) {
            //等待
            this.wait();
        }
        //加一
        num++;
        System.out.println(Thread.currentThread().getName() + "线程加一：" + num);
        //通知其他线程 我加一完毕了
        this.notifyAll();
    }

    public synchronized void decr() throws InterruptedException {
        if (num == 0) {
            //等待
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "线程减一：" + num);
        //通知其他线程 我减一完毕了
        this.notifyAll();
    }
}

2、如果有四个线程A、B、C、D同时执行呢？(虚假唤醒问题？)

package cn.dczh.juc;

/**
 * @ClassName: A
 * @description: A线程 B线程 操作同一个变量 num= 0  A:+1   B:-1
 * @author: 
 * @date: 2022/3/16 21:34
 * @version: 1.0
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();

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

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

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

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

class Data {

    private int num = 0;

    public synchronized void incr() throws InterruptedException {
        if (num != 0) {
            //等待
            this.wait();
        }
        //加一
        num++;
        System.out.println(Thread.currentThread().getName() + "线程加一：" + num);
        //通知其他线程 我加一完毕了
        this.notifyAll();
    }

    public synchronized void decr() throws InterruptedException {
        if (num == 0) {
            //等待
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "线程减一：" + num);
        //通知其他线程 我减一完毕了
        this.notifyAll();
    }
}

该代码执行结果为：

这种现象称为虚假唤醒 ！ 如何解决这种问题呢？  

将代码中的if判断改文文档中的while判断即可

class Data {

    private int num = 0;

    public synchronized void incr() throws InterruptedException {
        while (num != 0) {
            //等待
            this.wait();
        }
        //加一
        num++;
        System.out.println(Thread.currentThread().getName() + "线程加一：" + num);
        //通知其他线程 我加一完毕了
        this.notifyAll();
    }

    public synchronized void decr() throws InterruptedException {
        while (num == 0) {
            //等待
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "线程减一：" + num);
        //通知其他线程 我减一完毕了
        this.notifyAll();
    }
}

执行结果为：

 3、生产者与消费者问题 JUC版本

 

package cn.dczh.juc;

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

/**
 * @ClassName: B
 * @description:
 * @author: 
 * @date: 2022/3/16 22:08
 * @version: 1.0
 */
public class B {
    public static void main(String[] args) {
        Data2 data = new Data2();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) data.incr();
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) data.decr();
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) data.incr();
        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) data.decr();
        }, "D").start();

    }
}

class Data2 {

    private int num = 0;
    //获取lock锁
    final Lock lock = new ReentrantLock();
    //通过lock锁获取对象监视器
    final Condition condition = lock.newCondition();

    public void incr() {
        lock.lock();
        try {
            while (num != 0) {
                //等待
                condition.await();
            }
            //加一
            num++;
            System.out.println(Thread.currentThread().getName() + "线程加一：" + num);
            //通知其他线程 我加一完毕了
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

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

    }
}

4、Condition实现精种通知、唤醒线程 

 现有四个方法printA、printB、printC、printD,由四个线程A、B、C、D执行，A线程执行printA方法，执行完毕后唤醒B线程，执行printB方法，执行完毕后唤醒C线程执行printC方法，执行完毕后唤醒D线程，执行pringD方法，执行完毕后唤醒A线程 依此循环执行；

package cn.dczh.juc;

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

/**
 * @ClassName: C
 * @description:
 * @author: 
 * @date: 2022/3/16 22:22
 * @version: 1.0
 */
public class C {
    public static void main(String[] args) {
        Data3 data = new Data3();
        new Thread(() -> { for (int i = 0; i < 10; i++) data.printA(); }, "A").start();
        new Thread(() -> { for (int i = 0; i < 10; i++) data.printB(); }, "B").start();
        new Thread(() -> { for (int i = 0; i < 10; i++) data.printC(); }, "C").start();
        new Thread(() -> { for (int i = 0; i < 10; i++) data.printD(); }, "D").start();

    }
}

class Data3 {

    //获取lock锁
    final Lock lock = new ReentrantLock();

    final Condition conditionA = lock.newCondition();
    final Condition conditionB = lock.newCondition();
    final Condition conditionC = lock.newCondition();
    final Condition conditionD = lock.newCondition();

    //1:A线程 2：B线程 3：C线程 4：D线程
    private int flag = 1;

    public void printA(){
        try {
            lock.lock();
            while (flag != 1){
                //等待
                conditionA.await();
            }
            System.out.println("线程"+Thread.currentThread().getName()+"执行完毕！");
            //修改标示为2
            flag = 2;
            //唤醒指定的线程 B
            conditionB.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printB(){
        try {
            lock.lock();
            while (flag != 2){
                //等待
                conditionB.await();
            }
            System.out.println("线程"+Thread.currentThread().getName()+"执行完毕！");
            //修改标示为2
            flag = 3;
            //唤醒指定的线程 C
            conditionC.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printC(){
        try {
            lock.lock();
            while (flag != 3){
                //等待
                conditionC.await();
            }
            System.out.println("线程"+Thread.currentThread().getName()+"执行完毕！");
            //修改标示为2
            flag = 4;
            //唤醒指定的线程 D
            conditionD.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printD(){
        try {
            lock.lock();
            while (flag != 4){
                //等待
                conditionD.await();
            }
            System.out.println("线程"+Thread.currentThread().getName()+"执行完毕！");
            //修改标示为2
            flag = 1;
            //唤醒指定的线程 A
            conditionA.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }


}

执行结果如下：

小结 

 锁：锁的是new this 锁的是对象，static Clazz 锁的是唯一的类模板；

禅悟刂
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java生产者消费者的三种实现
az44yao的专栏
09-09 311
Java生产者消费者是最基础的线程同步问题，java岗面试中还是很容易遇到的，之前没写过多线程的代码，面试中被问到很尬啊，面完回来恶补下。在网上查到大概有5种生产者消费者的写法，分别如下。 用synchronized对存储加锁，然后用object原生的wait() 和 notify()做同步。 用concurrent.locks.Lock，然后用condition的await() 和signal()做同步。 直接使用concurrent.BlockingQueue。 使用PipedInputStre
Notify与Wait方法使用（一）
ljz2016的博客
03-30 361
一、基本使用 public class NotifyAndWait { public static void main(String[] args) throws InterruptedException { Person p=new Person(); MyThread myThread=new MyThread(p); MyThre...
JUC编程：生产者消费者问题
oneTreeTallTall
02-23 169
1什么是生产者消费者问题 举例：有一个盘子，你女朋友洗小番茄，他洗好一个放到盘子里，你从盘子里取拿来塞到自己嘴里，如果她不洗，那你就干巴巴的等着，这是一个很经典的问题，也是面试最经常问的也是最容易面试让手写的问题，接下里我们用传统的synchronized的写法和使用lock的写法进行实现，并且对比两种方式的差异。 2使用synchronized实现 使用实际工作中常用的方式书写 ...
多线程编程以及生产者消费者问题
cxn15335120506的博客
03-07 412
多线程编程
生产者与消费者问题（C语言 超详细全）小白可入
Zjyzzy123456789的博客
11-05 7290
【代码】生产者与消费者问题（详细全）
Java多线程-生产者与消费者问题
最新发布
02-03
### Java多线程-生产者与消费者问题 #### 一、生产者与消费者问题概览 **1.1 概要** 生产者与消费者问题是计算机科学中一个多线程同步的经典问题。它描述了两个线程如何共享有限资源的场景：一个是生产者...
Java——生产者-消费者问题
12-21
"生产者-消费者"问题是一个经典的多线程同步问题，主要涉及到进程间的协作与资源的共享。在这个问题中，生产者线程负责生产产品并将它们放入一个有限大小的缓冲区，而消费者线程则从缓冲区取出产品进行消费。为了...
Labview生产者与消费者.vi
07-19
生产者与消费者之间传递的数据是一个连续的sine波形，二者靠大小为30个点的缓冲区连接。右下角是“停止”按钮，控制程序的停止执行。例程提供了操作方式控件控制生产者和消费者的数据传递速率，包含五种状态：不生产...
C语言实现生产者消费者问题
05-27
C语言实现生产者消费者问题，分配具有n个缓冲区的缓冲池，作为共享资源。 定义两个资源型信号量empty 和full，empty信号量表示当前空的缓冲区数量，full表示当前满的缓冲区数量。 定义互斥信号量mutex，当某个进程...
Linux线程编程之生产者消费者问题
12-14
Linux线程编程中的生产者消费者问题是多线程编程中一个经典的同步问题，它涉及到线程间的协作和资源的共享。生产者线程负责生成数据并放入队列，而消费者线程则从队列中取出数据进行处理。在这个过程中，如何保证...
wait和notify的用法
gulanga5的博客
06-08 1175
432
wait和notify方法详解
qq_42261668的博客
11-06 2629
wait() 使当前线程等待，直到另一个线程为此对象调用notify（）方法或notifyAll（）方法。换句话说，这个方法的行为就像它只是执行wait（0）一样（如果没有当前对象notify（）唤醒就会一直等待）。 1.当前线程必须拥有此对象的monitor监视器（锁）。2.当前线程调用wait（）方法，线程就会释放此锁的所有权，并等待，3.直到另一个线程通过调用notify方法或notifyAll方法通知在该对象的监视器（锁）上等待的线程唤醒。4.然后线程等待，直到它可以重新获得监视器（锁）的所有权然
Java经典例题生产者/消费者问题——适合初学者
qq_42951717的博客
01-24 1753
本文旨在介绍如何使用代码简单的解决生产者/消费者问题，涉及到的知识点只有多线程的创建和同步方法以及wait()和notify()方法，适合初学Java多线程的人，目的是为了帮助初学者更好的理解这个问题如何用代码实现，手把手的从问题分析到代码实践，希望对各位有所帮助
你真的会正确使用wait和notify么?
欢迎来到我的博客，在这里我会用我的方式来讲解知识，请大家多多关照
01-01 530
synchronized(lock){//lock锁对象while(条件不成立){//条件不成立就一直等着}//符合条件执行业务代码....}//这边唤醒的线程要用notifyAll}上面就解决了虚假唤醒问题,以及能够让阻塞的同时,其他线程可以干活,在一定的时间内,可以高效的完成任务.以后在使用wait+notify的时候,就使用这么一套模板就行.已使用wait+notify就立马想到这套模板.参考黑马程序员视频01.001-为什么学习并发_哔哩哔哩_bilibili。
操作系统经典问题——消费者生产者问题
m0_53345417的博客
03-11 1246
P(mutex)和V(mutex)实现进程的互斥访问，P(empty)实现让缓冲区没满作为生产者生产的前操作，即当empty=0时即无空闲缓冲区数量时，让消费者消费作为生产者生产的前操作。P(mutex)和V(mutex)实现进程的互斥访问，V(empty)实现让缓冲区没满作为生产者生产的前操作，即当empty=0时即无空闲缓冲区数量时，让消费者消费作为生产者生产的前操作。V(full)实现让缓冲区不空作为消费者消费的前操作，即当full=0时即缓冲区全为空时，让生产者生产作为消费者消费的前操作。
超详解“生产者消费者问题”【操作系统】
热门推荐
m0_59731459的博客
06-06 1万+
超详解“生产者消费者问题”【操作系统】
【Java|多线程与高并发】wait和notify方法详解
云泽野の编程日记
06-22 1528
在Java多线程环境中,线程之间是抢占式执行的,线程的调度是随机的.这就很难受了. 在很多情况下我们希望线程以我们想要的顺序来执行. 这就需要wait和notify这两个方法wait和notify方法用于实现线程间的协作和通信.wait方法使线程进入等待状态，notify方法唤醒一个等待线程，notifyAll方法唤醒所有等待线程。通过上述三个方法，可以使线程按照特定的顺序执行或者等待某个条件满足后再执行。希望这篇文章能帮到你!专栏:《从零开始的Java学习之旅》在不断更新中,欢迎订阅!
用c语言实现“生产者和消费者”问题
weixin_52451652的博客
04-18 8101
实验要求：要求程序运行时，按任意键停止，显示各种信息 #include <stdio.h> #include<stdlib.h> #include<time.h> int mutex=1; int empty=10; int full=0; int buf[10]; int front=0,rear=0; int i; //p操作 .申请 void p(int *x) { *x=(*x)-1; } //v操作 .释放 void v(int *x) { *x=
编程实现生产者消费者问题
leo115的专栏
10-03 7019
#include #include #include #include void *producter_f (void * arg); void *consumer_f (void *arg); sem_t empty; //信号量 empty sem_t full; //信号量 full int running = 1; int apple_num = 0; int
Linux环境下的生产者消费者问题实现
在生产者消费者问题中，生产者和消费者共享一个有限的资源（这里是一只水果盘）。生产者可以放入水果，消费者则取出并消耗水果。为了保证正确性，需要防止多个生产者同时放入水果或多个消费者同时取出水果，即需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值