生产者和消费者（三种方式）

最新推荐文章于 2024-07-23 10:19:57 发布
最新推荐文章于 2024-07-23 10:19:57 发布
阅读量718 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39544980/article/details/107896449
版权

第一种：生产者和消费者（使用synchronized 锁）

此方法的特点：因为synchronized 锁只能创建一个队列，因此在唤醒其他线程的时候必须要唤醒所有的线程，才能保证生产者和消费者交替运行。代码实现如下;

Bread类

package com.qf.gp2002_2;

/*
 * wgy
 * 2020/8/5
 * 11:30
 */
public class Bread {
    private int id;
    private String productName;

    public Bread(int id, String productName) {
        this.id = id;
        this.productName = productName;
    }

    public Bread() {
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    @Override
    public String toString() {
        return "Bread{" +
                "id=" + id +
                ", productName='" + productName + '\'' +
                '}';
    }
}

BreadCon类

package com.qf.gp2002_2;

/*
 * wgy
 * 2020/8/5
 * 11:31
 */
public class BreadCon {
    //数组
    private Bread[] cons=new Bread[6];
    //元素个数
    private int size;
    //放入面包
    public synchronized void put(Bread b){
        while(size>5){
            //等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        cons[size]=b;
        System.out.println(Thread.currentThread().getName()+"生产了"+b.getId()+"号面包");
        size++;
        //唤醒消费者
        this.notifyAll();
    }
    //取走面包
    public synchronized void take(){
        while(size<=0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        size--;
        Bread b=cons[size];
        cons[size]=null;
        System.out.println(Thread.currentThread().getName()+"消费了"+b.getId()+"号面包，生产者:"+b.getProductName());

        //唤醒生产者
        this.notifyAll();

    }



}

生产者（Produce类）

public class Produce implements Runnable{
    private BreadCon con;
    public Produce(BreadCon con){
        this.con=con;
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            con.put(new Bread(i, Thread.currentThread().getName()));
        }
    }
}

消费者（Consume类）

public class Consume implements Runnable {
    private BreadCon con;

    public Consume(BreadCon con) {
        this.con = con;
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            con.take();
        }
    }
}

测试类（TestBread类）

public class TestBread {
    public static void main(String[] args) {
        //面包容器
        BreadCon breadCon=new BreadCon();
        //创建生产和消费
        Produce produce=new Produce(breadCon);
        Consume consume=new Consume(breadCon);
        //创建线程对象
        Thread zhuxi=new Thread(produce, "铸玺");
        Thread bingbing=new Thread(consume,"冰冰");
        Thread zhuxi2=new Thread(produce, "铸玺2");
        Thread bingbing2=new Thread(consume,"冰冰2");
        //启动
        zhuxi.start();
        bingbing.start();
        zhuxi2.start();
        bingbing2.start();
    }
}

第二种：生产者和消费者（使用Lock锁中的Condition接口）

此方法的特点：因为Condition接口具有创建多队列的能力，因此可以将生产者和消费者分别放入不同的队列中，因此在唤醒线程的时候可以指定唤醒消费者或者是生产者，不用唤醒全部线程就能够实现生产者和消费者交替运行的效果。代码实现如下：

Bread类

public class Bread {
    private int id;
    private String prouductName;

    public Bread(int id, String prouductName) {
        this.id = id;
        this.prouductName = prouductName;
    }

    public Bread() {
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getProuductName() {
        return prouductName;
    }

    public void setProuductName(String prouductName) {
        this.prouductName = prouductName;
    }

    @Override
    public String toString() {
        return "Bread{" +
                "id=" + id +
                ", prouductName='" + prouductName + '\'' +
                '}';
    }
}

BreadCon类

public class BreadCon {
    //数组容器
    private Bread[] con=new Bread[6];
    //元素个数
    private int size;
    //创建Lock
    private Lock lock=new ReentrantLock();
    //创建条件队列
    //Condition condition=lock.newCondition();
    //创建多个条件队列
    //生产者队列
    private Condition proCondition=lock.newCondition();
    //消费者队列
    private Condition conCondition=lock.newCondition();

    //放入元素
    public  void put(Bread b){
        //上锁
        lock.lock();
        try {
            while (size > con.length-1) {
                try {
                    proCondition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(size+"-----------------"+ Thread.currentThread().getName());
            con[size] = b;
            size++;
            System.out.println(Thread.currentThread().getName() + "生产了" + b.getId() + "号面包");
            //唤醒所有
            conCondition.signal();
        }finally {
            //解锁
            lock.unlock();
        }

    }

    //取出面包
    public  void take(){
        //上锁
        lock.lock();
        try {
            while(size <= 0) {
                try {
                    conCondition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            size--;
            System.out.println(size+"-----------------"+ Thread.currentThread().getName());
            Bread b = con[size];
            con[size] = null;
            System.out.println(Thread.currentThread().getName() + "消费了" + b.getId() + "号面包，生产者:" + b.getProuductName());
            proCondition.signal();
        }finally {
            //解锁
            lock.unlock();
        }
    }

}

测试

public class TestBread {
    public static void main(String[] args) {
        //创建容器
        BreadCon con=new BreadCon();
        //生产对象
        Runnable produce=new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    con.put(new Bread(i, Thread.currentThread().getName()));
                }
            }
        };
        //消费对象
        Runnable consume=new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    con.take();
                }
            }
        };
        //创建线程对象
        Thread zhuxi=new Thread(produce, "铸玺");
        Thread bingbing=new Thread(consume, "冰冰");
        Thread zhuxi2=new Thread(produce, "铸玺2");
        Thread bingbing2=new Thread(consume, "冰冰2");
        //启动线程
        zhuxi.start();
        zhuxi2.start();
        bingbing.start();
        bingbing2.start();
    }
}

第三种：生产者和消费者（使用阻塞队列）

此方法的特点：不需要手动唤醒线程，当生产了一定数量后生产者队列就会自动进入等待队列中，等到消费者消费。消费线程也是一样。注意的是在运行的过程中可能会发生运行完生产者还没有及时打印，就别消费者抢走了导致控制台输出出现了问题，但是运行结果是正确的生产多少就消费多少。不会产生多消费或者多生产的情况。代码实现如下：

public class TestBlockingQueue {
    public static void main(String[] args) {
        //1创建阻塞队列
        ArrayBlockingQueue<String> queue=new ArrayBlockingQueue<>(6);
//        LinkedBlockingQueue queue=new LinkedBlockingQueue(6);
        //2创建线程
        Runnable produce=new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<30;i++) {
                    try {
                        queue.put(Thread.currentThread().getName() + "---" + i);
                        System.out.println(Thread.currentThread().getName()+"生产了:"+i);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        Runnable consume=new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<30;i++) {
                    try {
                        String take = (String)queue.take();
                        System.out.println(Thread.currentThread().getName()+"消费了:"+take);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        new Thread(produce,"铸玺").start();
        new Thread(consume,"冰冰").start();

    }
}
风~叶～草
关注
生产者与消费者
weixin_48353691的博客
12-01 337
理解生产者与消费者，Queue队列线程安全，举例说明，Python代码实现
实现生产者与消费者问题的几种方式
Talk is cheap，show me the code.
03-28 921
生产者与消费者问题是多线程同步的一个经典问题。生产者和消费者同时使用一块缓冲区，生产者生产商品放入缓冲区，消费者从缓冲区中取出商品。我们需要保证的是，当缓冲区满时，生产者不可生产商品；当缓冲区为空时，消费者不可取出商品。 下面介绍java中几种解决同步问题的方式 wait()与notify()方法 Lock与Condition机制 BlockingQueue阻塞队列 ...
生产者/消费者模式(转载)
w57w57w57的专栏
09-07 3428
★简介     在实际的软件开发过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。     单单抽象出生产者和消费者，还够不上是生产者／消费者模式。该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而
【生产-消费模型】生产者 - 消费者模型原理及实现
最新发布
qq_38089448的博客
07-23 1154
假设有两个进程（或线程）A、B和一个固定大小的缓冲区，A进程生产数据放入缓冲区，B进程从缓冲区中取出数据进行计算，这就是一个简单的生产者-消费者模型。这里的A进程相当于生产者，B进程相当于消费者。
实现生产者-消费者模式的五种方式
MOKE_SPACE
08-23 2361
在学习完 RabbitMQ 后，才明白为什么那么喜欢问生产者-消费者问题，因为在很多开发领域都能派上用场。 在 Java基础 以及 操作系统 都有接触，但还是要在这里再总结一下。 synchronized、wait()、notify() wait()：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等待状态，让其他线程执行。 notify()：当生产者/消费者向缓冲区放...
生产者和消费者的三种实现方式（Java）
weixin_44730681的博客
02-15 1678
什么是生产者消费者问题 ? 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题是一个多线程同步问题的经典案例。该问题描述了共享固定大小缓冲区的两个线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。 注：该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。 要解决该问题，就必须让生产者在缓冲区满时休眠（要
手写生产者/消费者模式（三种方式）
qq_40480780的博客
01-02 1642
1.生产者/消费者模式介绍 这种模式满足三点要求： （1）生产者生产数据到缓冲区中，消费者从缓冲区中取数据。 （2）缓冲区满时，生产者线程阻塞。 （3）缓冲区空时，消费者线程阻塞。 模式组成： 公共的缓存队列（给予缓存上限）+ 生产者线程 + 消费者线程。 特点： 1.实现了生产者、消费者的解耦。 2.第一种方式，通过等待唤醒机制wait、notify/notifyAll + synchronized实现 阻塞队列 public class MyBlockingQueue { private int ma
Java"设计模式"——生产消费者模式及三种实现方式
xiaoaxiao
10-13 1845
Java设计模式——生产消费者模式 一、生产消费者模式原理   1、生产消费者模式主要是将生产者与消费者解耦，通过一个容器来解决生产者和消费者的强耦合问题，生产者消费者彼此之间不直接通讯，而是通过阻塞队列来进行通讯。   2、生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者也不找生产者要数据，而是直接从阻塞队列中取得，阻塞队列相当于一个缓冲区，平衡了生产者与消费者的处理能力，使得生...
生产者与消费者生产者与消费者
11-23
生产者与消费者生产者与消费者生产者与消费者生产者与消费者生产者与消费者
生产者与消费者问题
05-13
假设M个生产者和N个消费者共享一个具有K（K大于1）个缓冲区的循环缓冲结构BUFFER（提示：可以用一个循环队列或一个整型数组来表示），并设置两个指针IN和OUT，其中IN指向生产者线程当前可用的空缓冲区的在BUFFER中的下标，OUT指向消费者线程当前可用的满缓冲区在BUFFER中的下标。生产者线程和消费者线程并发执行，当无空缓冲区时，生产者线程阻塞；当无满缓冲区时消费者线程阻塞，并且多个生产者线程对IN的使用必须互斥，多个消费者线程对OUT的使用也必须互斥
生产者和消费者问题详解
世上只有一种英雄主义
02-17 5977
定义生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了共享固定大小缓冲区的两个线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的
Linux--生产者与消费者
哥不帅但很坏的博客
06-30 2977
基于单链表的生产者消费者模型。基于环形队列的生产者消费者模型。 生产者消费者问题，其实是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程—即所谓的“生产者”和“消费者”–在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放在缓冲区中，消费者在缓冲区消耗这些数据。但是，要保证生产者不会在缓冲区满时还往缓冲区写数据，消费者也不会在缓冲区为空时
生产者和消费者问题
XHHP
12-13 2448
生产者-消费者是一个经典的多线程协作问题。所谓生产者-消费者问题，实际上是包含两类线程，一种是生产者线程，用于生产数据，另一种是消费者线程，用于消费数据。为了解耦生产者和消费者的关系，通常会采用共享的数据区域。生产者往共享区域放数据，无需关心消费者的行为。消费者从共享区域取数据，无需关心生产者的行为。接下来，我们介绍几种方法来完成生产者-消费者模型。
生产者与消费者模式(理解)
weixin_34032779的博客
02-08 838
生产者/消费者模式：需要使用到同步，以及线程，属于多并发行列 产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。  单单抽象出生产者和消费者，还够不上是生产者／消费者模式。该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出数据。 解耦： 假设生产者和消费者分别是两个类。如果让生产者直接调用消费者的某个方法，那么生产者对于消费...
生产者和消费者的理解
qq_41986693的博客
01-20 1078
生产者和消费者用ReentrantLock+Condtion来实现 首先创建线程池来创建两个线程，然后分配相应的任务，生产者线程负责生产，消费者线程负责消费。为了让生产者和消费者之间解耦，有相关队列进行数据的存放。当队列为空或者满的时候，消费者/生产者线程等待，并且释放锁，自己处于等待状态。当队列中添加或者减少一个资源的时候，消费者/生产者线程会被唤醒，同时放弃锁，自己处于等待状态。 代码可以通过synchronized来锁着相应的队列对象，或者使用ReentrantLock+Condtion来进行操作。
Linux下生产者消费者模型的两种实现
"本文主要介绍了在Linux系统下如何实现生产者消费者模型，通过两种方法进行阐述，其中一种是结合信号量和互斥锁。" 在多线程编程中，生产者消费者模型是一种常见的同步和通信机制，用于解决线程间的协作问题。在该...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值