5-java多线程-生产者消费者模型

最新推荐文章于 2024-04-12 17:04:24 发布
最新推荐文章于 2024-04-12 17:04:24 发布
阅读量109 收藏
点赞数
分类专栏： java java基础 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43295763/article/details/120631134
版权

java多线程

文章目录

一、生产者消费者模型

这里采用的是最基本的生产者消费者模型，生产者生产资源，消费者消耗资源。

隐蔽知识点：生产者消费者模型一般不使用集合来模拟，这是因为集合会无限扩容，使用数组可以很好的展现效果

基本模型搭建如下：还未添加线程的同步机制

// 资源类
class Resource{

    // 定义容器用来存放数据或取数据的空间
    private Object[] data = new Object[1]; // 方便演示所以仅开辟一个空间
    private int num = 1;

    // 存放数据的方法
    public void save(){
        data[0] = "data"+num; // 正常而言应该是通过参数传入数据，这里为了演示将其写死,并通过num来体现生产的不同东西
        System.out.println(Thread.currentThread().getName()+"正存放的数据为"+data[0]);
        num++;
    }

    // 获取数据的方法
    public void get(){
        System.out.println(Thread.currentThread().getName()+"正取的数据为"+data[0]);
        data[0]=null;
    }
}

// producter
class Product implements Runnable{
    // 在生产者类中提供构造方法，目的是在创建线程的时候可以明确线程将来操作的资源本身
    private Resource r;
    public Product(Resource r){
        this.r = r;
    }
    public void run(){
        while(true){
            // 无限的生产资源
            r.save();
        }
    }
}


// consumer
class Consumer implements Runnable{
    private Resource r;
    public Consumer(Resource r){
        this.r = r;
    }
    public void run(){
        while(true){
            // 无限的消耗资源
            r.get();
        }
    }
}


class ThreadDemo {

    public static void main(String[] args) throws Exception {
        // 创建生产的任务对象
        Resource r = new Resource();
        Product p = new Product(r);
        Consumer c = new Consumer(r);
        
        Thread t1 = new Thread(p);// 生产者线程
        Thread t2 = new Thread(c);// 消费者线程

        t1.start();
        t2.start();

    }
}

二、生产者消费者模型的安全问题

由于cpu会在线程间切换，导致可能出现某个线程未完全跑完代码就切换到隔壁线程了。如消费者刚修改数据为null，就切换到生产者打印结果，那么打印结果自然为生产者生产了数据null。

Thread-0正存放的数据为 null
Thread-1正取的数据为 null

解决办法：加锁。

1.同步代码块

代码如下：区别就在于创建了锁，并用synchronized这一同步代码块来为线程同步区域加了锁。save方法与get方法用的是同一把锁，可以完成同步。

当然，这个代码也是存在问题的，它描述的场景是这样的，生产者可以一直生产，每次都会替换掉之前生成的产品；消费者可以一直消费，哪怕产品是null也会消费。也即是无限生产/无限消费，显然是不合理的。

class Resource{

    // 定义容器用来存放数据或取数据的空间
    private Object[] data = new Object[1]; // 方便演示所以仅开辟一个空间
    private int num = 1;

    private Object lock = new Object(); // 创建锁

    // 存放数据的方法
    public void save(){
        synchronized(lock){
            data[0] = "data"+num; // 正常而言应该是通过参数传入数据，这里为了演示将其写死,并通过num来体现生产的不同东西
            System.out.println(Thread.currentThread().getName()+"正存放的数据为 "+data[0]);
            num++;
        }
    }

    // 获取数据的方法
    public void get(){
        synchronized(lock){
            System.out.println(Thread.currentThread().getName()+"正取的数据为 "+data[0]);
            data[0]=null;
        }
    }
}

三、生产者消费者模型的同步问题

也即线程间通信问题。
无限生产/消费问题想要解决，我们思考一下情景。
生产者在生产时应该确定此时没有产品；消费者消费时应该确定此时有产品。也即是加入判断，在不满足条件时使线程等待。

线程间通信使用锁的wait与notify方法。也即是PV操作。
下列代码可以完成单生产者单消费者问题。

class Resource{

    // 定义容器用来存放数据或取数据的空间
    private Object[] data = new Object[1]; // 方便演示所以仅开辟一个空间
    private int num = 1;

    private Object lock = new Object(); // 创建锁

    // 存放数据的方法
    public void save(){
        synchronized(lock){
            if(data[0]!=null){
                // 如果有数据，那么生产者应该等待消费者取走
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            data[0] = "data"+num; // 正常而言应该是通过参数传入数据，这里为了演示将其写死,并通过num来体现生产的不同东西
            System.out.println(Thread.currentThread().getName()+"正存放的数据为 "+data[0]);
            num++;
            // 生产数据后要通知消费者可以消费了
            lock.notify();
        }
    }

    // 获取数据的方法
    public void get(){
        synchronized(lock){
            if(data[0]==null){
                // 如果没有数据，那么消费者应该等待生产者生产
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"正取的数据为 "+data[0]);
            data[0]=null;
            // 消费数据后要通知生产者可以生产了
            lock.notify();
        }
    }
}

四、生产者消费者模型的多生产多消费问题

上述代码只能完成单生产者单消费者问题，一旦开辟多个生产者/消费者，那么生产者唤醒锁的时候有可能唤醒了另一个生产者，那么就再次出现了无线生产问题。
落实在代码上，是因为线程被唤醒后会直接执行if后的代码。
解决方法：将 if 改为 while。一定可以解决问题，但是也有隐患，发生了死锁，所有线程都wait了。
死锁原因：唤醒的时候唤醒了自己的同伴，由于判断条件改为了while，导致同步再次判断依然被wait，最终导致没有可以执行的线程。
解决方法：JDK5之前只能采用notifyAll方法唤醒所有线程。唤醒的同伴会再次被wait，对方线程会干活，但是这种方式效率低。更希望的结果是唤醒对方线程。
或者使用JDK5中的condition接口，完成不同的等待唤醒机制监控不同的接口。

class Resource{

    // 定义容器用来存放数据或取数据的空间
    private Object[] data = new Object[1]; // 方便演示所以仅开辟一个空间
    private int num = 1;

    private Object lock = new Object(); // 创建锁

    // 存放数据的方法
    public void save(){
        synchronized(lock){
            while(data[0]!=null){
                // 如果有数据，那么生产者应该等待消费者取走
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            data[0] = "data"+num; // 正常而言应该是通过参数传入数据，这里为了演示将其写死,并通过num来体现生产的不同东西
            System.out.println(Thread.currentThread().getName()+"正存放的数据为 "+data[0]);
            num++;
            // 生产数据后要通知消费者可以消费了
            lock.notify();
        }
    }

    // 获取数据的方法
    public void get(){
		...
    }
}

五、lock+condition解决生产者消费者模型

同步问题要么使用synchronized同步代码块+notify/notifyAll来解决，要么使用lock+condition来解决，其中lock对应synchronized，condition对应notify。

如果使用lock+condition方法来解决问题，就和OS课程上学习的PV十分接近，代码如下：主要更改的地方有锁的创建、加锁去锁、PV操作。

此方法效率更高。

class Resource{

    // 定义容器用来存放数据或取数据的空间
    private Object[] data = new Object[1]; // 方便演示所以仅开辟一个空间
    private int num = 1;

	// 创建锁, Lock是一个接口，ReentrantLock是该接口的实现类
    private Lock l = new ReentrantLock(); 

	// 给Lock接口下绑定多个用于监视线程的Condition对象
	private Condition proCon = l.newCondition(); // 监视生产者线程，要绑定在锁l之上
	private Condition conCon= l.newCondition(); // 监视消费者线程，要绑定在锁l之上

    // 存放数据的方法
    public void save(){
        l.lock();// 手动上锁
        try{ // 使用try-finally的写法是为了一定执行unlock方法，否则出现意外如exception，那么可以不会unlock，就出问题了
            while(data[0]!=null){
                // 如果有数据，那么生产者应该等待消费者取走
                try {
                    proCon.await();// P是await()
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            data[0] = "data"+num; // 正常而言应该是通过参数传入数据，这里为了演示将其写死,并通过num来体现生产的不同东西
            System.out.println(Thread.currentThread().getName()+"正存放的数据为 "+data[0]);
            num++;
            // 生产数据后要通知消费者可以消费了
            conCon.signal();// V是signal()
        }finally{
       		// 手动解锁
            l.unlock();
        }
    }

    // 获取数据的方法
    public void get(){
		...
    }
}

完整代码


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

// 资源类
class Resource{
    // 定义容器用来存放数据或取数据的空间
    private Object[] data = new Object[1]; // 方便演示所以仅开辟一个空间
    private int num = 1;

	// 创建锁, Lock是一个接口，ReentrantLock是该接口的实现类
    private Lock l = new ReentrantLock(); 

	// 给Lock接口下绑定多个用于监视线程的Condition对象
	private Condition proCon = l.newCondition(); // 监视生产者线程，要绑定在锁l之上
	private Condition conCon= l.newCondition(); // 监视消费者线程，要绑定在锁l之上

    // 存放数据的方法
    public void save(){
        l.lock();// 手动上锁
        try{ // 使用try-finally的写法是为了一定执行unlock方法，否则出现意外如exception，那么可以不会unlock，就出问题了
            while(data[0]!=null){
                // 如果有数据，那么生产者应该等待消费者取走
                try {
                    proCon.await();// P是await()
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            data[0] = "data"+num; // 正常而言应该是通过参数传入数据，这里为了演示将其写死,并通过num来体现生产的不同东西
            System.out.println(Thread.currentThread().getName()+"正存放的数据为 "+data[0]);
            num++;
            // 生产数据后要通知消费者可以消费了
            conCon.signal();// V是signal()
        }finally{
       		// 手动解锁
            l.unlock();
        }
    }

    // 获取数据的方法
    public void get(){
        l.lock();
        try{
            while(data[0]==null){
                // 如果没有数据，那么消费者应该等待生产者生产
                try {
                    conCon.await();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"正取的数据为 "+data[0]);
            data[0]=null;
            // 消费数据后要通知生产者可以生产了
            proCon.signal();
        }finally{
            l.unlock();
        }
    }
}

// producter
class Product implements Runnable{
    // 在生产者类中提供构造方法，目的是在创建线程的时候可以明确线程将来操作的资源本身
    private Resource r;
    public Product(Resource r){
        this.r = r;
    }
    public void run(){
        while(true){
            // 无限的生产资源
            r.save();
        }
    }
}


// consumer
class Consumer implements Runnable{
    private Resource r;
    public Consumer(Resource r){
        this.r = r;
    }
    public void run(){
        while(true){
            // 无限的消耗资源
            r.get();
        }
    }
}


class ThreadDemo {

    public static void main(String[] args) throws Exception {
        // 创建生产的任务对象
        Resource r = new Resource();
        Product p = new Product(r);
        Consumer c = new Consumer(r);
        
        Thread t1 = new Thread(p);// 生产者线程
        Thread t11 = new Thread(p);// 生产者线程
        Thread t2 = new Thread(c);// 消费者线程
        Thread t21 = new Thread(c);// 消费者线程

        t1.start();
        t2.start();
        t11.start();
        t21.start();

    }
}
技不如人，甘拜下风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现生产者消费者模型的三种方式
gbj2020的博客
12-11 1546
生产者-消费者模型是一种多线程并发模型，其中生产者线程负责生产数据，并将数据放入共享的缓冲区中，而消费者线程则负责从缓冲区中取出数据并进行处理。
java多线程并发 ： 生产者-消费者模型的三种实现方式
火星男孩的分享空间
05-10 2751
生产者生产数据到缓冲区中，消费者从缓冲区中取数据。 如果缓冲区已经满了，则生产者线程阻塞； 如果缓冲区为空，那么消费者线程阻塞。 方式一：synchronized、wait和notify package day4; //wait 和 notify public class ProducerConsumerWithWaitNofity { public static void main(String[] args) { Resource resource = new Resource
一文理解java多线程之生产者消费者模型（三种实现）
最新发布
qq_43800449的博客
04-12 2187
生产者和消费者之间通过一个缓冲区来进行交互，生产者负责生成数据，然后存入缓冲区；消费者则负责消费数据，从缓冲区获取。生产者和消费者只和缓冲区交互，没有直接联系。其中的同步互斥关系：生产者之间互斥，消费者之间也互斥生产者与消费者之间既又同步也有互斥（缓冲区满时，只能消费完再生产；缓冲区空时，只能生产完再消费）注意：缓存区要先进先出，所以一般用队列实现为什么要用生产者-消费者模型？
【Java 基础篇】Java 生产者-消费者模式详解
繁依Fanyi的博客
09-20 2028
生产者-消费者模式是一种经典的多线程设计模式，用于解决多个线程之间的数据共享和协作问题。在生产者-消费者模式中，有两类线程：生产者线程和消费者线程。它们之间通过共享一个缓冲区（或队列）来协作，生产者将数据放入缓冲区，消费者从缓冲区取出数据并进行处理。生产者-消费者模式的主要目标是实现生产者和消费者之间的解耦，使它们可以独立地进行工作，从而提高系统的性能和可维护性。首先，我们定义一个有界缓冲区，使用来实现，它是 Java 并发包中提供的一个有界队列。} }} }} }
java多线程编程(三)----生产者消费者模型
weixin_65846395的博客
03-03 998
front说明队列为空。放入元素的时候先判满，满了不能放，然后tail位置上放入元素，让tail走到下一个位置。比如第一次0号下标放入“hello”注意一定不能写tail++，队列元素已满的时候，再次++会越界，加1取模会让tail在次回到头节点，从而循环起来。同理删除元素也让头节点++。注意也不能直接++，必须取模，其条件为 front = (front + 1) % length;有了前置知识，那么我们首先实现一个循环队列。
Java设计模式之生产者/消费者模式
红日
01-19 4300
一、什么是生产者/消费者模式？ 某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。在生产者与消费者之间在加个缓冲区，我们形象的称之为仓库，生产者负责往仓库了进商品，而消费者负责从仓库里拿商品，这就构成了生产者消费者模式。结构图如下： 二、生产者消费者模式的优点： 1、解耦: 由于有缓冲区的存在，生产者和消费者之间不直接依赖，耦合度降低。 2、支持并发: 由于生产者与消费者是两个独立的
Java多线程 生产者消费者模型实例详解
08-25
Java多线程生产者消费者模型是指在多线程环境下，生产者线程生产任务，消费者线程消费任务，而缓冲区是生产者和消费者之间的媒介。生产者消费者模型的主要组成部分包括生产者、消费者和缓冲区三个部分。生产者负责...
Java多线程 BlockingQueue实现生产者消费者模型详解
08-25
Java多线程BlockingQueue实现生产者消费者模型详解 Java多线程中，生产者消费者模型是非常重要的一种设计模式，它可以解决多线程之间的数据传输问题。在Java中，我们可以使用BlockingQueue来实现生产者消费者模型，...
java多线程经典模型生产者消费者
11-05
java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型...
JAVA多线程实现生产者消费者的实例详解
08-30
JAVA多线程实现生产者消费者是指在JAVA编程语言中使用多线程技术来实现生产者消费者模型的实例详解。生产者消费者模型是指在计算机科学中的一种经典模式，描述了生产者和消费者之间的协作关系。在这个模型中，生产者...
java实现多线程经典模型生产者消费
10-29
java实现多线程经典模型生产者消费java实现多线程经典模型生产者消费java实现多线程经典模型生产者消费java实现多线程经典模型生产者消费java实现多线程经典模型生产者消费java实现多线程经典模型生产者消费java实现...
生产者-消费者模型
07-20
EventClient EventQueueEventClient EventQueueEventClient EventQueueEventClient EventQueueEventClient EventQueue
生产者与消费者问题（操作系统的PV操作)
06-01
三个生产者生产数据，一个消费者消费数据，每次生产或消费10个字符，缓冲区大小为40.
Java 生产者消费者模式
10-22
自己空闲时间写的一个生产者和消费者模式。中间使用了中介者设计模式。大家可以参考下。
PV操作实现生产者消费者问题
05-14
PV操作实现生产者消费者问题PV操作实现生产者消费者问题PV操作实现生产者消费者问题PV操作实现生产者消费者问题
Java多线程：生产者消费者模型
流楚丶格念的博客
07-16 1945
一类是生产者线程用于生产数据一类是消费者线程用于消费数据为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为我们来看一个经典案例，可经典了，上课学，代码学，很多地方都会学到。...
11-JUC中的Condition对象
永无止境
04-28 598
文章目录ConditionCondition常用方法总结参考 Condition 任何一个java对象都天然继承于Object类，在线程间实现通信的往往会应用到Object的几个方法，比如wait()、wait(long timeout)、wait(long timeout, int nanos)与notify()、notifyAll()几个方法实现等待/通知机制，同样的， 在java Lock体...
Java实现生产者-消费者模型
weixin_33913332的博客
11-20 202
考查Java的并发编程时，手写“生产者-消费者模型”是一个经典问题。有如下几个考点： 对Java并发模型的理解 对Java并发编程接口的熟练程度 bug free coding style JDK版本：oracle java 1.8.0_102 本文主要归纳了4种写法，阅读后，最好在白板上练习几遍，检查自己是否掌握。这4种写法或者编程接口不同，或者并发粒度不同，但本质是相同的——都是在使...
生产消费模型详解以及代码实现（Java）
weixin_64625868的博客
04-09 1165
生产消费模型（Java代码示例）
用java实现多线程消费者和生产者模型
02-26
上述代码实现了一个简单的生产者和消费者模型，其中使用了一个线程安全的`LinkedList`队列作为生产者和消费者之间的缓冲区。在`Producer`和`Consumer`类中，`run()`方法被覆盖并实现了生产和消费的逻辑。 在生产者...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值