JDK1.8并发之生产者消费者问题

最新推荐文章于 2020-05-31 18:30:58 发布
最新推荐文章于 2020-05-31 18:30:58 发布
阅读量1k 收藏 2
点赞数
分类专栏： Java 文章标签： 并发
欢迎访问我的博客网站 https://thenorthsea.cn/
本文链接：https://blog.csdn.net/weixin_40255793/article/details/80791672
版权

本文讨论了生产者消费者模式的三种实现方式，第三种BlockingQueue实际上就是JDK对第二种方式的封装。为了提高程序的拓展性，方便测试，我用StockRoom接口来抽象产品库存的put和take操作。这样三种实现方式可以使用相同的Producer和Consumer类代码。这些可复用的代码如下：

// 测试方法：
private static void test(StockRoom stockRoom) {
    new Thread(new Consumer("销售小高", stockRoom)).start();
    new Thread(new Consumer("销售小田", stockRoom)).start();
    new Thread(new Producer("王工", stockRoom)).start();
    new Thread(new Producer("吴工", stockRoom)).start();
}

// 产品库操作的接口
interface StockRoom {
    void put(String operator, Object object) throws InterruptedException;

    Object take(String operator) throws InterruptedException;
}

// 生产者
class Producer implements Runnable {
    StockRoom stockRoom;
    String name;

    public Producer(String name, StockRoom stockRoom) {
        this.name = name;
        this.stockRoom = stockRoom;
    }

    @Override
    public void run() {
        while (true) {
            try {
                stockRoom.put(name, new Object());
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("销售员睡觉去了");
            }
        }
    }
}

// 消费者
class Consumer implements Runnable {
    StockRoom stockRoom;
    String name;

    public Consumer(String name, StockRoom stockRoom) {
        this.name = name;
        this.stockRoom = stockRoom;
    }

    @Override
    public void run() {
        while (true) {
            try {
                stockRoom.take(name);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("建筑工程师看电影去了");
            }
        }
    }
}


1. synchronized和wait、notifyAll实现

class StockRoomSyn implements StockRoom {
    private static final int MAX_STOCK_NUM = 10;

    private int N = 0;
    private Object[] stocks = new Object[MAX_STOCK_NUM];

    public synchronized void put(String operator, Object o) throws InterruptedException {
        Random random = new Random();

        while (N == MAX_STOCK_NUM) {
            System.out.println("库存太多了，停止生产@" + operator);
            wait();
        }

        Thread.sleep((random.nextInt(3) + 1) << 10);
        stocks[N++] = o;
        System.out.println(operator + "：又建好一件房子，现在的库存是：" + N);
        notifyAll();
    }

    public synchronized Object take(String operator) throws InterruptedException {
        Random random = new Random();

        while (N == 0) {
            System.out.println("诶呀，房子都卖完了@" + operator);
            wait();
        }

        Thread.sleep((random.nextInt(3) + 1) << 10);
        final Object o = stocks[--N];
        String msg = operator + "：经理，爸爸又卖出一套房子，现在的库存是：" + (--N);
        System.out.println(msg);
        notifyAll();
        return o;
    }
}

public static void test_syn() {
    test(new StockRoomSyn());
}
/*
    诶呀，房子都卖完了@销售小田
    诶呀，房子都卖完了@销售小高
    王工：又建好一件房子，现在的库存是：1
    销售小田：经理，爸爸又卖出一套房子，现在的库存是：0
    诶呀，房子都卖完了@销售小高
    王工：又建好一件房子，现在的库存是：1
    吴工：又建好一件房子，现在的库存是：2
    王工：又建好一件房子，现在的库存是：3
    销售小高：经理，爸爸又卖出一套房子，现在的库存是：2
    销售小田：经理，爸爸又卖出一套房子，现在的库存是：1
    销售小高：经理，爸爸又卖出一套房子，现在的库存是：0
    王工：又建好一件房子，现在的库存是：1
    吴工：又建好一件房子，现在的库存是：2
    王工：又建好一件房子，现在的库存是：3
    ...
*/

多个线程put和take的时候，使用notify容易出现死锁：

比如现在有1个take线程和1个put线程因为wait方法被要求进入等待队列，如果一个put线程正占据着锁，它用完之后notify，唤醒的如果是另一个put线程，而这个put线程拿到锁后，发现put条件不满足，进入wait方法。因为此时没有线程在锁池中，所以锁就空了。等待队列中的take和put线程都没有人来唤醒它们，进入了死锁状态。

这里写图片描述

这里写图片描述

当使用notifyAll的时候，所有等待池的线程都进入锁池，这样即使put线程因为wait方法进入了等待池，其他的线程还可以竞争锁，使得等待池有可能被唤醒。当然notifyAll并不能解决所有的死锁问题，只是比notify更不容易出错。

这体现了这种模式的缺点，就是notify或notifyAll唤醒的是所有等待锁的线程，既包括put又包括take。而实际应用中，应该区别对待，即put方法在执行结束前唤醒take等待的消费者线程，take方法在执行结束前唤醒put等待的生产者线程。这就是下面要介绍的第二种方式的优点之一。


2. Lock锁和Condition实现

class StockRoomLock implements StockRoom {

    private static final int MAX_STOCK_NUM = 10;

    private Object[] stocks = new Object[MAX_STOCK_NUM];
    private int N = 0;
    private Lock lock;
    private Condition notFull, notEmpty;

    public StockRoomLock() {
        lock = new ReentrantLock();
        notEmpty = lock.newCondition();
        notFull = lock.newCondition();
    }

    @Override
    public void put(String operator, Object o) throws InterruptedException {
        lock.lock();
        try {
            Random random = new Random();
            while (N == MAX_STOCK_NUM) {
                System.out.println("库存太多了，停止生产@" + operator);
                notFull.await();
            }
            Thread.sleep((random.nextInt(3) + 1) << 10);
            stocks[N++] = o;
            System.out.println(operator + "：又建好一件房子，现在的库存是：" + N);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public Object take(String operator) throws InterruptedException {
        lock.lock();
        try {
            Random random = new Random();
            while (N == 0) {
                System.out.println("诶呀，房子都卖完了@" + operator);
                notEmpty.await();
            }
            Thread.sleep((random.nextInt(3) + 1) << 10);
            final Object o = stocks[--N];
            System.out.println(operator + "：经理，爸爸又卖出一套房子，现在的库存是：" + N);
            notFull.signal();
            return o;
        } finally {
            lock.unlock();
        }
    }
}

public static void test_lock() {
    test(new StockRoomLock());
}
/*
    诶呀，房子都卖完了@销售小高
    王工：又建好一件房子，现在的库存是：1
    销售小田：经理，爸爸又卖出一套房子，现在的库存是：0
    吴工：又建好一件房子，现在的库存是：1
    销售小高：经理，爸爸又卖出一套房子，现在的库存是：0
    王工：又建好一件房子，现在的库存是：1
    销售小田：经理，爸爸又卖出一套房子，现在的库存是：0
    吴工：又建好一件房子，现在的库存是：1
    销售小高：经理，爸爸又卖出一套房子，现在的库存是：0
    王工：又建好一件房子，现在的库存是：1
    销售小田：经理，爸爸又卖出一套房子，现在的库存是：0
    吴工：又建好一件房子，现在的库存是：1
    销售小高：经理，爸爸又卖出一套房子，现在的库存是：0
    ...
*/


3. BlockingQueue实现

BlockingQueue就像是一个封装好的StockRoom对象，直接使用它的put和take方法就行了，这里的代码只是为了方便大家比较：

class StockRoomBQueue implements StockRoom {

    private static final int MAX_STOCK_NUM = 10;

    private BlockingQueue<Object> queue = new ArrayBlockingQueue<>(MAX_STOCK_NUM);

    @Override
    public void put(String operator, Object o) throws InterruptedException {
        queue.put(o);
    }

    @Override
    public Object take(String operator) throws InterruptedException {
        return queue.take();
    }
}

public static void test_queue() {
    test(new StockRoomBQueue());
}

ArrayBlockingQueue的源码就是用条件变量和Lock实现的：

构造器：

public ArrayBlockingQueue(int capacity) {
    this(capacity, false);
}

public ArrayBlockingQueue(int capacity, boolean fair) {
    if (capacity <= 0)
        throw new IllegalArgumentException();
    this.items = new Object[capacity];
    lock = new ReentrantLock(fair);
    notEmpty = lock.newCondition();
    notFull =  lock.newCondition();
}

相关字段：

/** The queued items */
final Object[] items;

/** Number of elements in the queue */
int count;

/** Main lock guarding all access */
final ReentrantLock lock;

/** Condition for waiting takes */
private final Condition notEmpty;

/** Condition for waiting puts */
private final Condition notFull;

put方法：

public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == items.length)
            notFull.await();
        enqueue(e);
    } finally {
        lock.unlock();
    }
}

private void enqueue(E x) {
    // assert lock.getHoldCount() == 1;
    // assert items[putIndex] == null;
    final Object[] items = this.items;
    items[putIndex] = x;
    if (++putIndex == items.length)
        putIndex = 0;
    count++;
    notEmpty.signal();
}

take方法：

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == 0)
            notEmpty.await();
        return dequeue();
    } finally {
        lock.unlock();
    }
}

private E dequeue() {
    // assert lock.getHoldCount() == 1;
    // assert items[takeIndex] != null;
    final Object[] items = this.items;
    @SuppressWarnings("unchecked")
    E x = (E) items[takeIndex];
    items[takeIndex] = null;
    if (++takeIndex == items.length)
        takeIndex = 0;
    count--;
    if (itrs != null)
        itrs.elementDequeued();
    notFull.signal();
    return x;
}

java.util.concurrent包中的BlockingQueue是高效且线程安全的队列接口，有五个具体的实现类（详细见参考资料2）：

  • ArrayBlockingQueue：由定长数组支持的有界拥塞队列。FIFO。
  • LinkedBlockingQueue：无界（如果构造时指定大小就有界）的拥塞队列，单链表结构。FIFO。
  • PriorityBlockingQueue：无界，平衡二叉堆的数组结构，保存的对象必须实现Comparable接口，按此比较规则来排序。迭代器的输出是二叉堆数组顺序，无法保证排序。
  • SynchronousQueue：没有内部容量，插入和取出需要成对使用，一个插入一个元素后还没结束就会阻塞，需要等待另一个线程取元素后，它们才一起结束。
  • DelayQueue：无界，用优先队列实现，元素必须实现java.util.concurrent.Delayed接口，take方法会阻塞到第一个到期的内部元素返回，通常根据元素的过期时刻来排序。


参考资料推荐

  1. 用Java实现生产者消费者的几种方法
  2. 【Java并发之】BlockingQueue


上一篇：JDK1.8并发之synchronized和Lock
下一篇：JDK1.8结合框架之Set

Harold Gao
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用java编写生产者消费者问题_java 模拟实现消费者和生产者问题
weixin_27230891的博客
02-13 635
题目要求用java代码模拟实现：一个人不断往箱子里放苹果，另一个人不断从箱子里取苹果，箱子只能放5个苹果，苹果数量无限。要求不使用java.util.concurrent包中的类。思路这道题主要考，java并发编程、Object.wai()、Object.notify()方法的使用、循环队列的使用1.使用两个线程分别模拟放苹果和取苹果。2.定义一个类放苹果，类里主要是对一个数组的封装注意：Obje...
JAVA——生产者与消费者以及JDK1.5以后新特性
Jungle_hello的博客
04-27 969
生产者和消费者问题是很常见的一类多线程问题。问题大致描述为： 有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个具有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，显然生产者和消费者之间必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已经放入产品的缓冲区中再次投放产
生产者-消费者的经典案例升级版(jdk1.5版)
java学习笔记
06-26 752
在jdk1.5中，多了一个新包java.util.concurrent，在这个包下面有关于线程操作的接口和类。这里主要用到了Lock和Condition。   package fighting; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import jav
Java多线程（九）：生产者消费者模型
weixin_30924087的博客
08-02 68
生产者消费者模型 生产者：生产任务的个体； 消费者：消费任务的个体； 缓冲区：是生产者和消费者之间的媒介，对生产者和消费者解耦。 当 缓冲区元素为满，生产者无法生产，消费者继续消费； 缓冲区元素为空，消费者无法消费，生产者继续生产； wait()/notify()生产者消费者模型 制作一个简单的缓冲区ValueObject，value为空表示缓冲区为空，value不为空表示缓冲区满 pu...
Java JDK1.5后生产消费者模式解决方案
风中的劲草
03-29 279
文章目录 一、思考 nofifyAll()方法是否存在效率问题？ 二、新特性 1、概述 2、总结 三、新特性的应用 1、Lock 2、Condition 四、优化代码示例 1、代码 2、注意点 一、思考 在上一篇博客 生产-消费者模式初探 中，我们用 while()循环判断标记位和notifyAll() 解...
jdk1.8+kafka3.2 linux版本
08-03
例如，提高了生产者和消费者的吞吐量，增强了安全性和稳定性，并且对Kafka Connect和Kafka Streams的API进行了更新。这些改进使得Kafka更适合大规模、高并发的实时数据处理场景。 在实际应用中，你可能还需要考虑...
java jdk1.8版本
最新发布
06-18
JDK 8u162是1.8系列的一个更新版本，修复了已知的安全漏洞和一些性能问题，确保了其在生产环境中的稳定性。对于开发人员来说，安装这个版本的JDK意味着可以利用上述的新特性和改进，同时享受到一个经过充分测试和...
jdk1.8安装包
04-23
本资源提供的`jdk1.8`是Oracle公司发布的Java 8更新151（8u151）的Windows 64位版本安装包，适用于在Windows操作系统上进行Java开发。 Java 8是Java的一个重要版本，它引入了许多新特性，旨在提高开发效率和代码...
jdk1.8_API文档
07-01
**Java Development Kit (JDK) 1.8...这个“jdk1.8_API文档”包含了上述所有特性的详细说明，是学习和开发Java 8应用的重要参考资料。尽管谷歌机翻可能会有些许瑕疵，但整体上仍然能够帮助开发者理解Java 8的关键特性。
jdk1.8-32.zip
08-28
首先，JDK1.8的主要新特性之一是Lambda表达式。这是一种简洁的函数式编程语法，使得处理集合变得更加方便，尤其在并行处理时。Lambda表达式可以替代匿名内部类，减少了代码量，提高了可读性。 其次，Java 8引入了...
【多线程高并发编程】四 java(jdk1.8)五种线程池,你都知道具体的应用场景吗？
12-23
程序猿学社的GitHub，欢迎Star https://github.com/ITfqyd/cxyxs 本文已记录到github，形成对应专题。 文章目录前言1.什么是线程池？2.实战2.1通过线程池代码创建线程2.1.Executors源码分析newFixedThreadPoolnewWorkStealingPool(int parallelism)newSingleThreadExecutor()newCachedThreadPool()newSingleThreadScheduledExecutor()newScheduledThreadPool(int corePoolSize) 前言
JDK8版本后生产者与消费者问题的代码实现
weixin_48149536的博客
05-31 302
package com.dym.jvm; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class ShareData//资源类 { private int number = 0;//初始值为零的一个变量 private Lock lock = ...
Java多线程 8 单一生产者消费者
窗边的倒影
09-19 975
著名的生产者和消费者，如果各只有一个，问题会很简单 package thread; /* 线程间通讯（间接通信）： 其实就是多个线程在操作同一个资源，但是操作的动作不同。 对于此类操作，一般来说可以把共同操作的那个共享资源作为锁（也可以用其他的，只要是用的同一个锁就行） 等待 - 唤醒 机制 sleep() Thread类的静态方法，将当前线程睡眠，不会释放任何资源 wait();
java线程基础巩固---线程生产者消费者的综合实战结合Java8语法
weixin_30500663的博客
05-10 118
基于上一次【http://www.cnblogs.com/webor2006/p/8909558.html】学习的多个生产者与多个消费者模型，此次用另外一个案例来进一步巩固线程之间的调度处理，这里还是以之前【http://www.cnblogs.com/webor2006/p/7895410.html】举过的信息采集功能为例：有若干台采集服务器，然后还有一台主机，这台主机需要等待这若干台服务器信息...
Java多线程基础(8)：生产者-消费者和队列
qq_36556651的博客
06-02 547
利用wait()和notify()实现任务间的协同合作其实是一种非常低级的方式，我们还可以使用同步队列来解决任务协作问题，BlockingQueue在任何时刻都只允许一个任务插入或者移除队列，如果消费者试图从队列中获取元素，而此时该队列为空，那么队列可挂起消费者，当队列内有元素时再恢复消费者任务。比wait()和notify()更简单好用。 有这么一个事件，需要制作吐司供顾客食用，而吐司的制作分三...
<JAVA学习笔记8>——生产者、消费者案例（2）
小冯的Blog
06-25 337
承接上篇博文，
生产者消费者之Java简单实现
weixin_34080951的博客
11-27 100
为什么要使用生产者和消费者模式 在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。 在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。 ...
java中实现生产者消费者（两种方式）
wenyuerpf的博客
11-30 154
一、wait(),notify()实现生产者消费者 import java.util.ArrayList; //测试类 public class MainMethed { public static void main(String[] args) { ProductPool pool = new ProductPool(8,new ArrayList<Product...
Java并发（八）生产消费问题&虚假唤醒
Bart_G的博客
05-06 884
描述生产消费问题在java多线程的学习中是经常遇到的问题 ，多个线程共享通一个资源的时候会出现各种多线程中经常出现的各种问题。实例说明三个类：售货员Clerk，工厂Factory，消费者Consumer Factory和Consumer共享Clerk对象1.普通情况 Clerk类： class Clerk{ //商品数量默认是0,volatile关键字保证内存可见性 private
2019版Java多线程实战教程：JDK1.8并发编程详解
在徐葳的《40小时掌握java语言之05多线程》内部教材中，该课程详细讲解了Java基础的多...该课程适合初学者和希望提升多线程编程能力的开发者，尤其对于那些使用JDK1.8及以上版本的Java开发者来说，提供了实用的指导。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值