一文带你吃透阻塞队列

已于 2022-07-18 15:07:53 修改
阅读量653 收藏 2
点赞数
文章标签： java 开发语言
于 2022-07-05 16:50:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40359381/article/details/125614543
版权

阻塞队列

什么是阻塞队列

我们在线程池参数中经常用到一个参数叫做阻塞队列，很多人不知道阻塞队列应该怎么选择，为了解决这个问题，我们需要先了解什么是阻塞队列。

要了解这个，我们需要先知道什么是队列。

队列是一种先进先出的线性表，在一端插入，另一端输出，可以把它想象成一个没有感情的单行道，里面的元素就类似于道上的车子。

那么让我们来看看阻塞队列又是什么呢？

一个队列的实现无非就是数组、链表等数据结构，它也有自己的大小，这里可以分为有界队列和无界队列，有界队列的大小是有限的，无界队列的大小为Integer.MAX，一定程度上可以理解为无限大，那么当有界队列满了，一端还在继续插入元素的时候，就应该阻塞，又或者队列空了，一端不断获取元素，也应该阻塞。

阻塞队列的作用

我们了解了什么是阻塞队列，那么它到底有什么用呢？阻塞队列在线程池和各种消息队列中经常用到，主要作用是缓冲，为了防止大量请求对服务器造成的压力过大，开辟了一块缓冲区，来限制流量。

阻塞队列的原理

首先我们需要理解AQS的一个运行原理。
在这里插入图片描述

阻塞队列的本质是利用了生产者消费者模式，利用lock锁以及Condition对线程进行操作来控制队列的状态，如果满了则对线程挂起并释放锁，即Condition.await()，如果添加元素成功或者删除元素成功则对指定线程进行唤醒，即Condition.signal()。
在这里插入图片描述

我们来看下简单实现

public class ConditionBlockedQueueExample {
    //表示阻塞队列中的容器
    private List<String> items;

    //元素个数(表示已经添加的元素个数)
    private volatile int size;

    //数组的容量
    private volatile int count;

    private Lock lock = new ReentrantLock();

    //让take方法阻塞
    private final Condition notEmpty = lock.newCondition();
    //让add方法阻塞
    private final Condition notFull = lock.newCondition();

    public ConditionBlockedQueueExample(int count) {
        this.count = count;
        items = new ArrayList<>(count);
    }

    //添加一个元素并且阻塞添加
    public void put(String item) throws InterruptedException {
        lock.lock();
        try {
            if (size >= count) {
                System.out.println("阻塞队列满了，需要等待");
                notFull.await();
            }
            ++size;
            items.add(item);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public String take() throws InterruptedException {
        lock.lock();
        try {
            if (size == 0) {
                System.out.println("阻塞队列空了，需要等待");
                notEmpty.await();
            }
            --size;
            String item = items.remove(0);
            notFull.signal();
            return item;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ConditionBlockedQueueExample cbqe = new ConditionBlockedQueueExample(10);
        Thread t1 = new Thread(() -> {
            Random random = new Random();
            for (int i = 0; i < 1000; i++) {
                String item = "item-" + i;
                try {
                    cbqe.put(item);
                    System.out.println("生产一个元素：" + item);
                    Thread.sleep(random.nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();

        Thread.sleep(1000);

        Thread t2 = new Thread(() -> {
            Random random = new Random();
            for (;;) {
                try {
                    String item = cbqe.take();
                    System.out.println("消费一个元素：" + item);
                    Thread.sleep(random.nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t2.start();
    }
}

阻塞队列的方法

了解了阻塞队列的原理后，我们回想线程池中的拒绝策略，类比这里，是不是所有的阻塞队列满了以后就都是进行阻塞呢？
答案显然是否定的。
在阻塞队列中，不管是添加还是移除元素，都存在不同的策略。
我们以ArrayBlockingQueue为例。

阻塞队列抛出异常有返回值等待阻塞等待超时
入队方法add()offer()put()offer(值,超时时间,超时单位)
出队方法remove()poll()take()poll(超时时间,超时单位)
获取队顶方法element()peek()
队满或队空输出结果抛出异常返回false或null一直阻塞等待超时

JUC中的阻塞队列

JUC中有很多种阻塞队列，不同的阻塞队列的使用场景不同。

  • ArrayBlockingQueue 基于数组结构
  • LinkedBlockingQueue 基于链表结构
  • PriorityBlockingQueue 基于优先级队列
  • DelayQueue 允许延时执行的队列
@ToString
public class DelayQueueExampleTask implements Delayed {
    private String orderId;
    private long start = System.currentTimeMillis();
    private long time;

    public DelayQueueExampleTask(String orderId, long time) {
        this.orderId = orderId;
        this.time = time;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert((start+time)-System.currentTimeMillis(),TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        return (int)(this.getDelay(TimeUnit.MILLISECONDS)-o.getDelay(TimeUnit.MILLISECONDS));
    }
}

public class DelayQueueTest {
    private static DelayQueue<DelayQueueExampleTask> delayQueue = new DelayQueue<>();
    public static void main(String[] args) throws InterruptedException {
        delayQueue.offer(new DelayQueueExampleTask("1001",5000));
        delayQueue.offer(new DelayQueueExampleTask("1002",4000));
        delayQueue.offer(new DelayQueueExampleTask("1003",3000));
        delayQueue.offer(new DelayQueueExampleTask("1004",2000));
        delayQueue.offer(new DelayQueueExampleTask("1005",1000));
        while (!delayQueue.isEmpty()){
            DelayQueueExampleTask task = delayQueue.take();
            System.out.println(task);
        }

    }
}

在这里插入图片描述

  • SynchronousQueue 没有任何存储结构的队列(在线程池中newCacheThreadPool中可用到，可以处理非常大请求的任务)
  • LinkedTransferQueue 由链表构建的无界阻塞队列，保证生产者和消费者是一对一的关系
  • LinkedBlockingDeque 双向链表组成的队列，支持双向的插入和移除，在一定程度上能够解决多线程的竞争问题,ForkJoin的使用的就是这种。

阻塞队列的使用

阻塞队列在平时很多场景都可以使用，比如责任链模式，构建一条执行链路。

首先定义一个责任链接口

public interface IRequestProcessor {
    void processRequest(Request request);
}

再构建一个链式的实现

public class ValidProcessor extends Thread implements IRequestProcessor{

    protected IRequestProcessor nextProcessor;

    protected BlockingQueue<Request> requests = new LinkedBlockingDeque<>();

    public ValidProcessor(IRequestProcessor nextProcessor) {
        this.nextProcessor = nextProcessor;
    }

    @Override
    public void processRequest(Request request) {
        requests.add(request);
    }

    @Override
    public void run() {
        while (true){
            try {
                Request request = requests.take();
                System.out.println("执行了" + this.getClass().getSimpleName() + "责任链");
                Optional.ofNullable(nextProcessor).ifPresent(k->nextProcessor.processRequest(request));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class SaveRequestProcessor extends Thread implements IRequestProcessor{

    protected IRequestProcessor nextProcessor;

    protected BlockingQueue<Request> requests = new LinkedBlockingDeque<>();

    public SaveRequestProcessor(IRequestProcessor nextProcessor) {
        this.nextProcessor = nextProcessor;
    }

    @Override
    public void processRequest(Request request) {
        requests.add(request);
    }

    @Override
    public void run() {
        while (true){
            try {
                Request request = requests.take();
                System.out.println("执行了" + this.getClass().getSimpleName() + "责任链");
                Optional.ofNullable(nextProcessor).ifPresent(k->nextProcessor.processRequest(request));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class PrintProcessor extends Thread implements IRequestProcessor{

    protected IRequestProcessor nextProcessor;

    protected BlockingQueue<Request> requests = new LinkedBlockingDeque<>();

    public PrintProcessor(IRequestProcessor nextProcessor) {
        this.nextProcessor = nextProcessor;
    }

    @Override
    public void processRequest(Request request) {
        requests.add(request);
    }

    @Override
    public void run() {
        while (true){
            try {
                Request request = requests.take();
                System.out.println("执行了" + this.getClass().getSimpleName() + "责任链");
                Optional.ofNullable(nextProcessor).ifPresent(k->nextProcessor.processRequest(request));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class FinalRequestProcessor  extends Thread implements IRequestProcessor {

    protected IRequestProcessor nextProcessor;

    protected BlockingQueue<Request> requests = new LinkedBlockingDeque<>();

    @Override
    public void processRequest(Request request) {
        requests.add(request);
    }

    @Override
    public void run() {
        while (true){
            try {
                Request request = requests.take();
                System.out.println("执行了" + this.getClass().getSimpleName() + "责任链");
                Optional.ofNullable(nextProcessor).ifPresent(k->nextProcessor.processRequest(request));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

通过线程将责任链的请求加到阻塞队列中，在构建链式结构后启动线程，即可通过生产者消费者模式异步处理链上的请求。

public class ChainExample {
    public static void main(String[] args) {
        FinalRequestProcessor finalRequestProcessor = new FinalRequestProcessor();
        finalRequestProcessor.start();
        SaveRequestProcessor saveRequestProcessor = new SaveRequestProcessor(finalRequestProcessor);
        saveRequestProcessor.start();
        PrintProcessor printProcessor = new PrintProcessor(saveRequestProcessor);
        printProcessor.start();
        ValidProcessor validProcessor = new ValidProcessor(printProcessor);
        validProcessor.start();
        Request request = new Request();
        validProcessor.processRequest(request);
    }
}

通过阻塞队列可以做很多非实时的数据处理，比如订单详情信息，物流实时信息等，这种方式可以防止大量请求堆积，在某些场景下可以提升较多的系统性能。

倔强100%
关注
阻塞队列BlockingQueue
我能在河边钓一整天的鱼
06-01 718
目录 什么是阻塞队列 阻塞队列家族 阻塞队列的4种常用API 同步队列SynchronousQueue 什么是阻塞队列 队列是先进先出的。如果队列满了，新元素想进来不得不阻塞。如果队列是空的，想取出队列中的元素也不得不阻塞 阻塞队列广泛应用在线程池技术和各种消息队列中间件的底层中~ 阻塞队列家族 阻塞队列家族属于Clollection集合的成员，Queue与Set和List是平级 阻塞队列的4种常用API 第一...
一文吃透 Go 内置 RPC 原理
捉虫大师
03-02 411
本文介绍了 Go 内置的 RPC Client 和 Server 端原理，能窥探出一点点 RPC 的设计，如果让你实现一个 RPC 是不是有些可以参考呢？本来草稿中贴了很多代码，但我觉得那样解读很难读下去，于是就删了又删。
阻塞队列
07-13 845
原文地址  By Jakob Jenkov   翻译：寒桐 校对：方腾飞 阻塞队列与普通队列的区别在于，当队列是空的时，从队列中获取元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样，试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他的线程使队列重新变得空闲起来，如从
阻塞队列简介
最新发布
qq_34358193的博客
07-18 385
是一个基于数组的有界阻塞队列，必须在创建时指定其容量。阻塞队列在 Java 并发编程中是非常有用的工具，适用于各种场景。通过使用阻塞队列，可以简化多线程间的任务调度、资源共享和负载均衡，确保线程安全和高效的并发处理。选择合适的阻塞队列：根据具体需求选择合适的阻塞队列，如有界队列（ArrayBlockingQueue）、无界队列（LinkedBlockingQueue）、优先级队列（PriorityBlockingQueue）、延迟队列（DelayQueue）等。使用阻塞方法：使用puttake。
队列阻塞
不想成为架构师的程序员不是一个好研发!
11-22 245
阻塞队列 import java.util.LinkedList; import java.util.List; public class BlockingQueue { private List&lt;Object&gt; queue = new LinkedList&lt;Object&gt;(); private int limit = 10; public BlockingQueu...
BlockingQueue（堵塞队列）
qq_45525367的博客
11-26 323
BlockingQueue（堵塞队列） 日常记录 常见堵塞队列： BlockingQueue：堵塞队列 DelayQueue：死信队列 ArrayBlockingQueue：数组堵塞队列 LinkedBlockingQueue：链表堵塞队列 ConcurrentLinkedQueue：并发链表堵塞队列（线程安全） 文档介绍： 一丶ArrayBlockingQueue     一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。队列的头部 是
java进阶
JOHN
01-30 1545
1. 大数据2. 中间件3. 高性能4. 高并发5. 高可用6. 网关7. 缓存8. devops9. java基础10. 数据库11. DDD12.Netty13.MQ14. Zookeeper15. 其他。
【走进浏览器】谈一谈浏览器渲染的基本原理
m0_67402564的博客
03-09 154
浏览器渲染基本原理 浏览器对于前端工程师，就相当于赛车于赛车手，想要更好的在赛道上驰骋，就需要对自己的赛车有更深入的了解，甚至人车合一，所以本篇文章我们就来打开浏览器的大门，一起努力吧！ 前言 一篇文章很难将所有的细节覆盖，同时我们也不需要将所有流程和每一个环节都摸透，我们就依照脉络来聊一聊浏览器的渲染过程。 我们都知道一个页面通常由三个部分组成，即HTMl+CSS+JS，并通过一系列的步骤转换。 HTML 的内容是由标记和文本组成 CSS 称为层叠样式表，是由选择器和属性组成 JS 是可以使网页的内
Java学习专栏！全网最牛！
weixin_70730532的博客
08-12 2617
00254:《SpringCloud Alibaba微服务实战十四 - SpringCloud Gateway集成Oauth2.0》00242:《SpringCloud Alibaba微服务实战二十四 - SpringCloud Gateway的全局异常处理》00251:《SpringCloud Alibaba微服务实战十五 - SpringCloud 容器化部署》00248:《SpringCloud Alibaba微服务实战十八 - Oauth2.0 自定义授权模式》00184:《TCP网络那点破事！..
聊聊并发-Java中的阻塞队列
weixin_33895695的博客
12-23 580
转自：http://www.infoq.com/cn/articles/java-blocking-queue1. 什么是阻塞队列？阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，...
一文带你吃透操作系统csdn
09-20
操作系统是计算机系统中的核心组成部分，负责管理和协调计算机硬件和软件资源，提供程序运行环境。在CSDN上有很多关于操作系统的专题文章，以下将从操作系统的基本概念、功能和常见类型等方面简要介绍一下。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值