Java并发编程 之实现生产者消费者

最新推荐文章于 2023-04-26 09:27:27 发布
最新推荐文章于 2023-04-26 09:27:27 发布
阅读量270 收藏 1
点赞数
分类专栏： # Java并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/const_/article/details/110734768
版权

文章目录


上联：线程、操作（对外暴露的调用方法）、资源类
下联：判断、干活、唤醒通知
横幅：严防多线程并发状态下的虚假唤醒

使用synchronize以及wait()、notify() /notifyAll()

class ShareData {

    public static AtomicInteger atomicInteger = new AtomicInteger();
    public volatile boolean flag = true;
    public static final int MAX_COUNT = 10;
    public static final List<Integer> pool = new ArrayList<>();

    public void produce() {
        // 判断、干活、通知
        while (flag) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            synchronized (pool) {
                // 判断
                if (pool.size() == MAX_COUNT) {
                    // 池子满了，生产者停止生产
                    try {
                        System.out.println(Thread.currentThread().getName() + "\t pool is full, waiting...");
                        pool.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 干活
                pool.add(atomicInteger.incrementAndGet());
                System.out.println(Thread.currentThread().getName() + "\t produce number:" + atomicInteger.get() + "\t" + "current size:" + pool.size());
                //通知
                pool.notifyAll();
            }
        }
    }

    public void consumer() {
        // 判断、干活、通知
        while (flag) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            synchronized (pool) {
                // 判断
                if (pool.size() == 0) {
                    // 池子空的，停止消费
                    try {
                        System.out.println(Thread.currentThread().getName() + "\t pool is empty, waiting...");
                        pool.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 干活
                System.out.println(Thread.currentThread().getName() + "\t consumer number:" + pool.get(0) + "\t" + "current size:" + pool.size());
                pool.remove(0);
                //通知
                pool.notifyAll();
            }

        }
    }

    public void stop() {
        flag = false;
    }

}

public class ProducerConsumerDemo {

    public static void main(String[] args) {
        ShareData shareData = new ShareData();
        new Thread(() -> {
            shareData.produce();
        }, "AAA").start();

        new Thread(() -> {
            shareData.consumer();
        }, "BBB").start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        shareData.stop();
    }
}

上面的程序在只有两个线程时（一个生产者，一个消费者）可以正常工作。
在这里插入图片描述
但是把生产者和消费者线程扩展至多个。就出错了。例如再增加CCC和DDD线程分别生产和消费。只改动了main方法：

public class ProducerConsumerDemo {

    public static void main(String[] args) {
        ShareData shareData = new ShareData();
        new Thread(() -> {
            shareData.produce();
        }, "AAA").start();

        new Thread(() -> {
            shareData.consumer();
        }, "BBB").start();
        new Thread(() -> {
            shareData.produce();
        }, "CCC").start();

        new Thread(() -> {
            shareData.consumer();
        }, "DDD").start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        shareData.stop();
    }
}

在这里插入图片描述
看到 current size 能到11了。这肯定出错了。因为要求pool的最大容量为10。出现这个情况的原因是在多线程的环境下，要防止虚假唤醒。即判断条件不能用 if，而是用 while。最终版正确的代码如下：

class ShareData {

    public static AtomicInteger atomicInteger = new AtomicInteger();
    public volatile boolean flag = true;
    public static final int MAX_COUNT = 10;
    public static final List<Integer> pool = new ArrayList<>();

    public void produce() {
        // 判断、干活、通知
        while (flag) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            synchronized (pool) {
                // 判断
                while (pool.size() == MAX_COUNT) {
                    // 池子满了，生产者停止生产
                    try {
                        System.out.println(Thread.currentThread().getName() + "\t pool is full, waiting...");
                        pool.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 干活
                pool.add(atomicInteger.incrementAndGet());
                System.out.println(Thread.currentThread().getName() + "\t produce number:" + atomicInteger.get() + "\t" + "current size:" + pool.size());
                //通知
                pool.notifyAll();
            }
        }
    }

    public void consumer() {
        // 判断、干活、通知
        while (flag) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            synchronized (pool) {
                // 判断
                while (pool.size() == 0) {
                    // 池子空的，停止消费
                    try {
                        System.out.println(Thread.currentThread().getName() + "\t pool is empty, waiting...");
                        pool.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 干活
                System.out.println(Thread.currentThread().getName() + "\t consumer number:" + pool.get(0) + "\t" + "current size:" + pool.size());
                pool.remove(0);
                //通知
                pool.notifyAll();
            }

        }
    }

    public void stop() {
        flag = false;
    }

}

public class ProducerConsumerDemo {

    public static void main(String[] args) {
        ShareData shareData = new ShareData();
        new Thread(() -> {
            shareData.produce();
        }, "AAA").start();

        new Thread(() -> {
            shareData.consumer();
        }, "BBB").start();
        new Thread(() -> {
            shareData.produce();
        }, "CCC").start();

        new Thread(() -> {
            shareData.consumer();
        }, "DDD").start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        shareData.stop();
    }
}

在这里插入图片描述

使用Lock并结合Condition的await和signal方法

JUC包下的锁Lock替代synchronize关键字。await方法代替wait，signalAll代替notifyall。

class ShareData {

    private static AtomicInteger atomicInteger = new AtomicInteger();
    private volatile boolean flag = true;
    private static final int MAX_COUNT = 10;
    private static final List<Integer> pool = new ArrayList<>();
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void produce() {
        // 判断、干活、通知
        while (flag) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            lock.lock();
            try {
                // 判断
                while (pool.size() == MAX_COUNT) {
                    // 池子满了，生产者停止生产
                    try {
                        System.out.println(Thread.currentThread().getName() + "\t pool is full, waiting...");
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 干活
                pool.add(atomicInteger.incrementAndGet());
                System.out.println(Thread.currentThread().getName() + "\t produce number:" + atomicInteger.get() + "\t" + "current size:" + pool.size());
                //通知
                condition.signalAll();
            } finally {
                lock.unlock();
            }
        }
    }

    public void consumer() {
        // 判断、干活、通知
        while (flag) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            lock.lock();
            try {
                // 判断
                while (pool.size() == 0) {
                    // 池子空的，停止消费
                    try {
                        System.out.println(Thread.currentThread().getName() + "\t pool is empty, waiting...");
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 干活
                System.out.println(Thread.currentThread().getName() + "\t consumer number:" + pool.get(0) + "\t" + "current size:" + pool.size());
                pool.remove(0);
                //通知
                condition.signalAll();
            } finally {
                lock.unlock();
            }
        }
    }

    public void stop() {
        flag = false;
    }

}

public class ProducerConsumerDemo {

    public static void main(String[] args) {
        ShareData shareData = new ShareData();
        new Thread(() -> {
            shareData.produce();
        }, "AAA").start();

        new Thread(() -> {
            shareData.consumer();
        }, "BBB").start();
        new Thread(() -> {
            shareData.produce();
        }, "CCC").start();

        new Thread(() -> {
            shareData.consumer();
        }, "DDD").start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        shareData.stop();
    }
}

阻塞队列版本

使用阻塞队列根本不需要去加锁，通知，完全通过阻塞队列进行阻塞和通知了。

class ShareData {

    private static AtomicInteger atomicInteger = new AtomicInteger();
    private volatile boolean flag = true;
    // 阻塞队列
    private static BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<>(10);

    public void produce() {
        while (flag) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            try {
                int incrementAndGet = atomicInteger.incrementAndGet();
                boolean value = blockingQueue.offer(incrementAndGet, 2, TimeUnit.SECONDS);
                int size = blockingQueue.size();
                if (value == true) {
                    System.out.println(Thread.currentThread().getName() + "\t 成功插入队列 \t" + incrementAndGet + "\t资源队列大小= " + size);
                } else {
                    System.out.println(Thread.currentThread().getName() + "\t 失败插入队列" + incrementAndGet + "\t资源队列大小= " + size);
                }
            } catch (InterruptedException e) {
            }
        }
    }

    public void consumer() {
        // 判断、干活、通知
        while (flag) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            try {
                Integer result = blockingQueue.poll(2, TimeUnit.SECONDS);
                if (null == result) {
                    System.out.println("超过两秒没有取道数据，消费者即将退出");
                    return;
                }
                System.out.println(Thread.currentThread().getName() + "\t 成功消费 \t" + result + "\t" + "资源队列大小= " + blockingQueue.size());
            } catch (InterruptedException e) {
            }
        }
    }

    public void stop() {
        flag = false;
    }

}

public class ProducerConsumerDemo {

    public static void main(String[] args) {
        ShareData shareData = new ShareData();
        new Thread(() -> {
            shareData.produce();
        }, "AAA").start();

        new Thread(() -> {
            shareData.consumer();
        }, "BBB").start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        shareData.stop();
    }
}

在这里插入图片描述

yyangqqian
关注
专栏目录
java多线程并发之生产者消费者
qq_43538170的博客
03-24 137
通俗来讲，生产者就是好比如吃自助的时候的厨师，消费者就是我们吃自助的人。只有厨师做了菜，消费者才可以吃；而当没有人吃的时候厨师停止做菜。 在 Java 中,负责产生数据的模块是生产者,负责使用数据的模块是消费者. 生产者消费者解决数据的平衡问题,即先有数据然后才能使用,没有数据时,消费者需要等待。 在此可能生产者与消费者的数量可能是： 1.一个生产者与一个消费者 2.一个生产者多个消费者 3.多个生产者多个消费者 简单地代码例示如下： package com.company.producerdata; /
Java 并发编程 生产者消费者模式
低吟不作语的博客
04-05 372
本文部分摘自《Java 并发编程的艺术》 模式概述 在线程的世界里，生产者就是生产数据的线程，消费者就是消费数据的数据。生产者和消费者彼此之间不直接通信，而是通过阻塞队列进行通信，所以生产者生产完数据后不用等待消费者处理，而是直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列取，阻塞队列相当于一个缓冲区，平衡了生产者和消费者的处理能力 模式实战 假设现有需求：把各部门的邮件收集起来，统一处理归纳。可以使用生产者 - 消费者模式，启动一个线程把所有邮件抽取到队列中，消费者启动多个线程处理邮..
Java并发-生产者消费者实现
abc123mma的博客
11-27 659
生产者消费者实现
Java线程深入学习(三)
xxyneymar的博客
09-22 102
第四章、线程间通信 4.1 等待/通知机制 4.1.1 什么是等待通知机制 在单线程编程中，要执行的操作需要满足一定的条件才能执行，可以把这个条件放在if语句块中。而在多线程编程中，可能线程A的条件没有满足，但是这种情况只是暂时的，稍后其他的线程B可能更新条件使得线程A的条件得到满足，此时可以将线程A暂停，直到它的条件得到满足后再将线程A唤醒，这个步骤的伪代码： atomics{ //原子操作 while(条件不成立){ ...
【java并发系列】java多线程实现生产者消费者模式
Think_and_work的博客
03-16 2223
简介 一般来说，生产者和消费者模式可以实现对任务数量的控制，防止任务过多，导致程序处理不来。 主要思想 当队列满时，生产者需要等待队列有空间才能继续往里面放入商品，而在等待的期间内，生产者必须释放对临界资源（即队列）的占用权。因为生产者如果不释放对临界资源的占用权，那么消费者就无法消费队列中的商品，就不会让队列有空间，那么生产者就会一直无限等待下去。 因此，一般情况下，当队列满时，会让生产者交出对临界资源的占用权，并进入挂起状态。然后等待消费者消费了商品，然后消费者通知生产者队列有空间了。 同样地，当队列
JAVA多线程实现生产者消费者的实例详解
08-30
JAVA多线程实现生产者消费者是指在JAVA编程语言中使用多线程技术来实现生产者消费者模型的实例详解。生产者消费者模型是指在计算机科学中的一种经典模式，描述了生产者和消费者之间的协作关系。在这个模型中，生产者...
Java并发编程中的生产者与消费者模型简述
09-03
在Java并发编程中，生产者与消费者模型是一种常见的多线程设计模式，它用于解决不同线程间的协作问题，特别是涉及数据共享的情况。这个模型通常包括两个主要角色：生产者和消费者，以及一个共享的数据存储区，即仓库...
java并发编程实战源码,java并发编程实战pdf,Java
09-10
10. **并发模式**：书中可能还会介绍生产者消费者模式、读写锁模式、双端队列模式等经典的并发设计模式，帮助开发者解决实际问题。 通过学习《Java并发编程实战》的源码，你可以更直观地了解这些概念如何在实际代码...
Java实现简易生产者消费者模型过程解析
08-19
生产者消费者模型是一种常见的并发编程模型，在Java中可以通过使用同步机制和wait/notify机制来实现。在本文中，我们将通过一个简单的示例代码介绍Java实现简易生产者消费者模型的过程。 二、Java实现生产者消费者...
Java多线程生产者消费者模式实现过程解析
08-19
* Java并发编程艺术 * Java高并发编程技术 我们可以看到，生产者消费者模式是Java多线程编程中一个非常重要的模式，广泛应用于高并发和高性能要求的系统中。正确地实现该模式可以提高系统的性能和效率，减少系统的...
Java 生产者消费者并发实例
taizhen/blog
07-01 377
写了一段代码 来熟悉生成着消费者以及wait notify 方法。 package test; public class MyRestaurant {    MyMeal meal; MyChef chef = new MyChef(this); MyWaiter waiter = new MyWaiter(this); public MyRestaurant() {
JUC并发编程之生产者消费者两种实现
xzystart的博客
01-24 3791
使用传统JUC锁实现 public class ProducerAndConsumerTraditionalDemo { class Data { private int number = 0; // 资源 private Lock lock = new ReentrantLock(); // 可重入锁 private Condition condition = lock.newCondition(); public void increment() throws Exc
Java实现生产者消费者问题
最新发布
无简介
04-26 4908
生产者-消费者问题是计算机科学中经典的同步问题之一，它描述了多个线程在共享数据的情况下如何协同工作。该问题通常涉及到一个共享缓冲区，其中生产者线程生成数据并将其放入缓冲区，而消费者线程从缓冲区中取出数据并对其进行处理。生产者和消费者线程必须协同工作，以避免竞态条件和死锁等问题。以上为通过Java代码实现解决生产消费者问题的实例，通过本实例希望大家能学会如果解决此问题，学会如何数据共享时，各个线程协同工作。
java 多线程并发系列之 生产者消费者模式的两种实现
热门推荐
小鱼的专栏
05-14 1万+
生产者消费者模式是并发、多线程编程中经典的设计模式，生产者和消费者通过分离的执行工作解耦，简化了开发模式，生产者和消费者可以以不同的速度生产和消费数据。 真实世界中的生产者消费者模式 生产者和消费者模式在生活当中随处可见，它描述的是协调与协作的关系。比如一个人正在准备食物（生产者），而另一个人正在吃（消费者），他们使用一个共用的桌子用于放置盘子和取走盘子，生产者准备食物，如
Java并发编程 【生产者消费者模式的实现】
半 岛 码 农 的 博 客
02-14 1107
最简单的实现方式是利用阻塞队列，废话不多说，上代码： wait、notify、notifyAll是Object对象的属性，并不属于线程。我们先解释这三个的一个很重要的概念 wait：使持有该对象的线程把该对象的控制权交出去，然后处于等待状态，并释放锁 notify：通知某个正在等待这个对象的控制权的线程可以继续运行,同样也是释放锁 notifyAll:会通知所有等待这个对象控制权的线程继续运行 ...
多线程-生产者和消费者模式的四种实现
Fly_Fly_Zhang的博客
05-29 6814
什么是生产者和消费者模式： 生产者和消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此并不直接通信，而是通过阻塞队列进行通信，所以生产者生产完数据后不用等待消费者进行处理，而是直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列中获取数据，阻塞队列就相当于一个缓冲区，平衡生产者和消费者的处理能力。 wait/notify和synchronized配合实现： 生产者...
Java生产者消费者的五种实现方式
zgj12138的博客
06-30 4426
前言生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。 现在用四种方式来实现生产者消费者模型
Java并发编程系列20:多线程之生产者和消费者模式(使用Lock中Condition的await/signalAll)
fen_fen的专栏
01-18 1647
Java多线程之生产者和消费者模式(使用Lock中Condition的await/signalAll)
Java多线程学习三：有哪几种实现生产者消费者模式的方法
徘徊在牛A与牛C之间的码农
02-21 241
我们先来看看什么是生产者消费者模式，生产者消费者模式是程序设计中非常常见的一种设计模式，被广泛运用在解耦、消息队列等场景。在现实世界中，我们把生产商品的一方称为生产者，把消费商品的一方称为消费者，有时生产者的生产速度特别快，但消费者的消费速度跟不上，俗称“产能过剩”，又或是多个生产者对应多个消费者时，大家可能会手忙脚乱。如何才能让大家更好地配合呢？这时在生产者和消费者之间就需要一个中介来进行调度，于是便诞生了生产者消费者模式。 使用生产者消费者模式通常需要在两者之间增加一个阻塞队列作为媒介，有了媒介之后就
Java并发学习：BlockingQueue生产者消费者实现详解
在Java并发编程的学习中，BlockingQueue是一个至关重要的概念，它是Java util.concurrent包中的核心数据结构，提供了线程安全的队列操作，适用于生产者-消费者模型的场景。阻塞队列允许线程在尝试插入数据到满队列或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值