java之阻塞队列（BlockingQueue）

已于 2023-09-25 17:21:03 修改
阅读量2.6k 收藏 15
点赞数 1
分类专栏： 技术 文章标签： 队列 java
于 2021-01-22 11:36:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43824267/article/details/112978702
版权
本文深入介绍了Java中的阻塞队列，包括其概念、优势以及不同类型的阻塞队列如ArrayBlockingQueue、LinkedBlockingQueue和SynchronousQueue。通过示例代码展示了阻塞队列在生产者消费者模式中的应用，强调了其在多线程环境中的高效与线程安全特性。
摘要由CSDN通过智能技术生成

java之阻塞队列

一、阻塞队列概念

阻塞队列，顾名思义，首先它是一个队列（先进先出），而一个阻塞队列在数据结构所起到的作用大致如下图：
在这里插入图片描述

  • 线程1往阻塞队列中添加元素，而线程2从阻塞队列中移除元素
  • 当阻塞队列是空是，从队列中获取元素的操作会被阻塞
  • 当阻塞队列是满时，从队列中添加元素的操作会被阻塞
  • 试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。
  • 试图网已满的阻塞队列中添加新元素的线程同样会被阻塞，直到其他的线程从列中移除一个或者多个元素或者完全清空队列后使队列重新变得空闲起来并后续新增

二、阻塞队列的好处

1.在多线程领域：所谓阻塞，在某些情况下会挂起线程，一旦满足条件，被挂起的线程又会自动被唤醒。

2.我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为这一切BlockingQueue（阻塞队列）都给你一手包办了

PS：在concurrent包发布以前，在多线程环境下，我们每个程序员都必须自己控制这些细节，尤其还要兼顾效率和线程安全，而这回给我们程序带来不小的复杂度

三、阻塞队列种类

  • ArrayBlockingQueue：由数据结构组成的有界阻塞队列
  • LinkedBlockingQueue：由链表结构组成的有界（但大小默认值为 Integer.MAX_VALUE )阻塞队列
  • PriorityBlockingQueue：支持优先级排序的无界阻塞队列
  • DelayQueue：使用优先级队列实现的延迟无界阻塞队列
  • SynchronousQueue：不存储元素的阻塞队列，也即单个元素的队列
  • LinkedTransferQueue：由链表结构组成的无界阻塞队列
  • LinkedBlockingDeque：由历览表结构组成的双向阻塞队列

PS：重点掌握ArrayBlockingQueue、LinkedBlockingQueue、SychronousQueue三种

四、BlockingQueue的核心方法

方法类型抛出异常特殊值一直阻塞超时退出
插入add(e)offer(e)put(e)offer(e,time,unit)
移除remove()poll()takepoll(time,unit)
检查element()peek()不可用不可用

说明：

方法类型情况
抛出异常当阻塞队列满时，再往队列中add会抛 IllegalStateException: Queue full；
当阻塞队列空时，再从队列里remove会抛 NoSuchElementException
特殊值offer(e)插入方法，成功true失败false
poll() 移除方法，成功返回出队列的元素，队列里没有就返回null
一直阻塞当阻塞队列满时，生产者线程继续往队列里put元素，队列会一直阻塞线程直到take数据或响应中断退出
当阻塞队列空时，消费者线程试图从队列take元素，队列会一直阻塞消费者线程直到队列可用
超时退出当阻塞队列满时，队列会阻塞生产者线程一定时间，超过限时后生产者线程会退出

五、示例代码

1.使用SychronousQueue队列
package com.jian8.juc.queue;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/*
 * 阻塞队列SynchronousQueue演示
 * */
public class SynchronousQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<String> blockingQueue = new SynchronousQueue<>();

        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + "\t put 1");
                blockingQueue.put("1");
                System.out.println(Thread.currentThread().getName() + "\t put 2");
                blockingQueue.put("2");
                System.out.println(Thread.currentThread().getName() + "\t put 3");
                blockingQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "AAA").start();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + "\t take" + blockingQueue.take());

                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + "\t take" + blockingQueue.take());

                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + "\t take" + blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "BBB").start();
    }
}

运行结果：
在这里插入图片描述

2.传统版生产者消费者模式
package com.jian8.juc.queue;

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

/**
 * 一个初始值为零的变量，两个线程对其交替操作，一个加1一个减1，来5轮
 * 1. 线程  操作  资源类
 * 2. 判断  干活  通知
 * 3. 防止虚假唤起机制
 */
public class ProdConsumer_TraditionDemo {
    public static void main(String[] args) {
        ShareData shareData = new ShareData();
        for (int i = 1; i <= 5; i++) {
            new Thread(() -> {
                try {
                    shareData.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "ProductorA " + i).start();
        }

        for (int i = 1; i <= 5; i++) {
            new Thread(() -> {
                try {
                    shareData.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "ConsumerA  " + i).start();
        }

        for (int i = 1; i <= 5; i++) {
            new Thread(() -> {
                try {
                    shareData.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "ProductorB " + i).start();
        }

        for (int i = 1; i <= 5; i++) {
            new Thread(() -> {
                try {
                    shareData.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "ConsumerB  " + i).start();
        }

    }
}

//资源类
class ShareData {
    private int number = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    //生产
    public void increment() throws Exception {
        lock.lock();
        try {
            //1.判断
            while (number != 0) {
                //等待中，不能生产
                condition.await();
            }
            //2.干活
            number++;
            System.out.println(Thread.currentThread().getName() + "\t" + number);
            //3.通知
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //消费
    public void decrement() throws Exception {
        lock.lock();
        try {
            //1.判断
            while (number == 0) {
                //等待中，不能消费
                condition.await();
            }
            //2.消费
            number--;
            System.out.println(Thread.currentThread().getName() + "\t" + number);
            //3.通知
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

运行结果（部分）：
在这里插入图片描述

3.阻塞队列版（以ArrayBlockingQueue为例）生产者消费者模式
package com.jian8.juc.queue;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ProdConsumer_BlockQueueDemo {
    public static void main(String[] args) {
        MyResource myResource = new MyResource(new ArrayBlockingQueue<>(10));

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t生产线程启动");
            try {
                myResource.myProd();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "Prod").start();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t消费线程启动");
            try {
                myResource.myConsumer();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "Consumer").start();

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("5s后main叫停，线程结束");

        try {
            myResource.stop();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//资源类
class MyResource {
    private volatile boolean flag = true;//默认开启，进行“生产+消费”活动
    private AtomicInteger atomicInteger = new AtomicInteger();
    BlockingQueue<String> blockingQueue = null;//消息队列

    public MyResource(BlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
        System.out.println(blockingQueue.getClass().getName());
    }

    //生产
    public void myProd() throws Exception {
        String data = null;
        boolean retValue;
        while (flag) {
            data = atomicInteger.incrementAndGet() + "";
            //超过2s没生产成功，退出生产
            retValue = blockingQueue.offer(data, 2, TimeUnit.SECONDS);
            if (retValue) {
                System.out.println(Thread.currentThread().getName() + "\t插入队列" + data + "成功");
            } else {
                System.out.println(Thread.currentThread().getName() + "\t插入队列" + data + "失败");
            }
            TimeUnit.SECONDS.sleep(1);
        }
        System.out.println(Thread.currentThread().getName() + "\t大老板叫停了，flag=false，生产结束");
    }

    //消费
    public void myConsumer() throws Exception {
        String result = null;
        while (flag) {
            //超过2s没从队列获取数据，消费退出
            result = blockingQueue.poll(2, TimeUnit.SECONDS);
            if (null == result || result.equalsIgnoreCase("")) {
                flag = false;
                System.out.println(Thread.currentThread().getName() + "\t超过2s没有取到蛋糕，消费退出");
                System.out.println();
                return;
            }
            System.out.println(Thread.currentThread().getName() + "\t消费队列" + result + "成功");
        }
    }

    public void stop() throws Exception {
        flag = false;
    }
}

运行结果：
在这里插入图片描述

强强爱java
关注
专栏目录
Java之BlockingQueue
我的E家
08-10 231
LinkedBlockingQueue https://www.jianshu.com/p/6ba87c7508e4 基于链表的阻塞队列，同ArrayListBlockingQueue类似，其内部也维持着一个数据缓冲队列（该队列由一个链表构成），当生产者往队列中放入一个数据时，队列会从生产者手中获取数据，并缓存在队列内部，而生产者立即返回；只有当队列缓冲区达到最大值缓存容量时（LinkedBlockingQueue可以通过构造函数指定该值），才会阻塞生产者队列，直到消费者从队列中消费掉一份数据，生...
Java阻塞队列poll_Java高并发，阻塞队列BlockingQueue
weixin_33309048的博客
02-24 1543
BlockingQueue简介BlockingQueue：不是新的东西，父接口java.util.Queue当队列为空时，从队列中获取元素将阻塞。当队列为满时，从队列中添加元素将阻塞。因为是队列，所以我们理应想到先进先出。BlockingQueue常用APIboolean将指定的元素插入到此队列中，如果可以立即执行此操作而不违反容量限制， true在成功后返回 IllegalStateExcept...
聊聊并发（七）——Java 中的阻塞队列
怀素的专栏
05-10 209
1. 什么是阻塞队列？ 阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。 阻塞队列提供了四种处理方法: ...
JavaEE 初阶（11）——多线程9之“阻塞队列”
最新发布
2301_80243321的博客
07-29 2287
本篇主要是一些“阻塞队列”的相关知识，讲解了阻塞队列在“生产者消费者模型”中的应用
Java阻塞队列
2301_76161469的博客
12-23 1391
阻塞队列(Blocking Queue)是一种特殊的队列，因其为队列，因此遵循“先进先出”的原则，此外，其是一种线程安全的数据结构，具有以下两点特性：1. 当队列满时，继续入队列就会阻塞，直到有线程将元素从队列中取出2. 当队列空时，继续出队列就会阻塞，直到有线程向队列中插入元素阻塞队列常用于“生产者消费者模型什么是“生产者消费者模型”？“生产者消费者模式”是一种典型的开发模型，通过一个容器来解决生产者和消费者的强耦合问题向队列中添加元素的线程向队列中取出元素的线程。
图灵学院：Java高并发之BlockingQueue
热门推荐
JAVA这点事
05-11 3万+
1：BlockingQueue继承关系  java.util.concurrent 包里的 BlockingQueue是一个接口， 继承Queue接口，Queue接口继承 Collection  BlockingQueue-----&gt;Queue--&gt;Collection 图： 队列的特点是：先进先出（FIFO）2：BlockingQueue的方法BlockingQueue 具有 4 组...
Java 中的阻塞队列
weixin_52383177的博客
09-21 2181
阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取元素的线程。阻塞队列就是生产者用来存放元素、消费者用来获取元素的容器。
BlockingQueu 阻塞队列
dizan4060的博客
09-14 296
java.util.concurrent public interface BlockingQueue<E> extends Queue<E> 简介 当阻塞队列插入数据时： 如果队列已经满了，线程则会阻塞等待队列中元素被取出后在插入。 当从阻塞队列中取数据时，如果队列是空的，则线程会阻塞等待队列中有新元素。 阻塞队列（BlockingQueue...
java 中 阻塞队列BlockingQueue详解及实例
08-30
Java中的阻塞队列BlockingQueue是一种并发编程中常用的工具，它实现了线程间的同步和通信。阻塞队列的核心特性在于当队列为空时，尝试获取元素的线程会被阻塞，直到其他线程添加元素；当队列满时，尝试添加元素的...
详解Java阻塞队列(BlockingQueue)的实现原理
08-30
"详解Java阻塞队列(BlockingQueue)的实现原理" Java阻塞队列（BlockingQueue）是Java.util.concurrent包下重要的数据结构，提供了线程安全的队列访问方式。BlockingQueue的实现原理主要是基于四组不同的方法用于...
14-阻塞队列BlockingQueue实战及其原理分析二.pdf
06-09
阻塞队列（BlockingQueue）是一种特殊的队列，它支持两个附加操作：阻塞的插入方法put和阻塞的移除方法take。BlockingQueue继承了Queue接口，是Java 5中加入的。 BlockingQueue常用方法示例： 1. add(E e)：添加一...
10、阻塞队列BlockingQueue实战及其原理分析
03-07
阻塞队列BlockingQueue是Java并发编程中一个重要的数据结构，它是线程安全的队列，主要用于生产者消费者模型中的数据交换。在Java的`java.util.concurrent`包中，提供了多种实现阻塞队列的类，如`ArrayBlockingQueue...
Java中的阻塞队列
uk8692的专栏
06-26 359
阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。1、支持阻塞的插入方法：当队列满时，队列会阻塞插入元素的线程，直到队列不满。2、支持阻塞的移除方法：在队列为空时，获取元素的线程会等待队列变为非空。阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取元素的线程。阻塞队列就是生产者用来存放元素、消费者用来获取
java中的阻塞队列
小海子的博客
06-14 348
前言 在去年的面试过程中，被面试官问道“阻塞队列”这个问题，因为当时并没有对此问题进行深入理解，只是按照自己的理解说明了该问题，最后面试结果也不太好，今天对该问题进行简要的面试并记录如下；如有错误，欢迎指正。 什么是阻塞队列 在数据结构中，队列遵循FIFO（先进先出）原则。在java中，Queue接口定义了定义了基本行为，由子类完成实现，常见的队列有ArrayDeque、LinkedList等，这些都是非线程安全的，在java 1.5中新增了阻塞队列，当队列满时，添加元素的线程呈阻塞状态；当队列为空时，获取
Java常见的阻塞队列
张紫娃的博客
05-24 1558
----------------------------------------------------------------------------摘自 书名：Java并发编程的艺术 作者：方腾飞；所谓公平访问队列是指阻塞的线程，可以按照阻塞的先后顺序访问队列，即先阻塞线程先访问队列。）是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。在阻塞队列不可用时，这两个附加操作提供了4种处理方式。插入和移除操作的4中处理方式。JDK 7提供了7个阻塞队列。什么是线程公平的访问队列？
【Java】阻塞队列
Creativity + Efficiency = Success
03-06 1307
介绍阻塞队列的定义、种类、实现原理以及应用。
Java BlockingQueue
lzc_23的博客
05-06 877
本文翻译自http://tutorials.jenkov.com/java-util-concurrent/blockingqueue.html，机翻加人工校正，仅供学习交流。 Java BlockingQueue接口 Java BlockingQueue接口表示一个线程安全的队列，可以将元素放入，也可以取出。换句话说，多个线程可以同时从Java Bloc中插入和获取元素，不会有任何并发性问题。 阻塞队列这个术语就来自于Java BlockingQueue 接口能够阻塞试图在队列插入或获取元素的线程。如果一
Java BlockingQueue 简介
wre_most2的专栏
12-24 564
使用BlockingQueue的关键技术点如下:     1.BlockingQueue定义的常用方法如下:         1)add(anObject):把anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则招聘异常         2)offer(anObject):表示如果可能的话,将anObject加到Bloc
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

强强爱java

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值