ArrayBlockingQueue与LinkedBlockingQueue底层原理

news2025/1/13 7:50:02

ArrayBlockingQueue与LinkedBlockingQueue底层原理

在线程池中，等待队列采用ArrayBlockingQueue或者LinkedBlockingDeque，那他们是怎么实现存放线程、阻塞、取出的呢？

一、ArrayBlockingQueue底层原理

1.1 简介

ArrayBlockingQueue是一个阻塞的队列，继承了AbstractBlockingQueue，间接的实现了Queue接口和Collection接口。 底层以数组的形式保存数据，所以它是基于数组的阻塞队列。ArrayBlockingQueue是有边界值的，在创建ArrayBlockingQueue时就要确定好该队列的大小，一旦创建，该队列大小不可更改。
内部的全局锁是使用的ReentrantLock。

1.2 关系图谱

在这里插入图片描述

1.3 父类BlockingQueue的方法梳理
public interface BlockingQueue<E> extends Queue<E> {
    //将对象塞入队列，如果塞入成功返回true, 否则返回false。
    boolean add(E e);

    //将对象塞入到队列中，如果设置成功返回true, 否则返回false
    boolean offer(E e);

    //将元素塞入到队列中，如果队列中已经满了，
    //则该方法会一直阻塞，直到队列中有多余的空间。
    void put(E e) throws InterruptedException;

    //将对象塞入队列并设置时间
    //如果塞入成功返回 true, 否则返回 false.
    boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException;

    //从队列中取对象，如果队列中没有对象，
    //线程会一直阻塞，直到队列中有对象，并且该方法取得了该对象。
    E take() throws InterruptedException;

    //在给定的时间里，从队列中获取对象，
    //时间到了直接调用普通的poll方法，为null则直接返回null。
    E poll(long timeout, TimeUnit unit)
        throws InterruptedException;

    //获取队列中剩余长度。
    int remainingCapacity();

    //从队列中移除指定的值。
    boolean remove(Object o);

    //判断队列中包含该对象。
    public boolean contains(Object o);

    //将队列中对象，全部移除，并加到传入集合中。
    int drainTo(Collection<? super E> c);

    //指定最多数量限制将队列中对，全部移除，并家到传入的集合中。
    int drainTo(Collection<? super E> c, int maxElements);
}
1.4 ArrayBlockingQueue源码解析
1.4.1 参数解释
	/** 队列中存放的值 */
    final Object[] items;

    /** 值的索引，这是取出位置的索引*/
    int takeIndex;

    /** 值的索引，这是插入位置的索引*/
    int putIndex;

    /** 队列中有多少个元素 */
    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;
1.4.2 构造方法
	/**
  	* capacity 表示数组中最大容量，默认使用非公平锁
  	*/
   public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
    }
 	/**
  	* capacity 表示数组中最大容量
  	* fair 为 false 时使用非公平锁，true 时使用公平锁
  	*/
    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();
    }

	/**
  	* capacity 表示数组中最大容量
  	* fair 为 false 时使用非公平锁，true 时使用公平锁
  	* c 初始化时，可以加入将我们有的集合加入该队列中
 	*/
    public ArrayBlockingQueue(int capacity, boolean fair,
                              Collection<? extends E> c) {
        this(capacity, fair);

        final ReentrantLock lock = this.lock;
        lock.lock(); // Lock only for visibility, not mutual exclusion
        try {
            int i = 0;
            try {
                for (E e : c) {
                    checkNotNull(e); //判空
                    items[i++] = e;
                }
            } catch (ArrayIndexOutOfBoundsException ex) {
                throw new IllegalArgumentException();
            }
            count = i;
            putIndex = (i == capacity) ? 0 : i;
        } finally {
            lock.unlock();
        }
    }
1.4.3 存入数据的put方法
public void put(E e) throws InterruptedException {
	//判空
    checkNotNull(e);
    //显示锁
    final ReentrantLock lock = this.lock;
    //可中断锁
    lock.lockInterruptibly();
    try {
    	//判断队列元素是否以及满了，满了就阻塞，如果队列满了await 是阻塞队列
        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)
        	//满了就将下一个入队索引设置为 0 
            putIndex = 0;
        count++;
        //唤醒 其他阻塞的出队操作
        notEmpty.signal();
    }
1.4.4 取出数据的take方法
  public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        //可中断锁
        lock.lockInterruptibly();
        try {
            while (count == 0)
            	//如果队列数量为0，则阻塞取数据的锁
                notEmpty.await();
                //队列长度不为0，开始取数据
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

从队列取出数据

 private E dequeue() {
        //取得当前items对象
        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;
    }

二、LinkedBlockingQueue底层原理

2.1 主要参数 解释
//队列中元素个数
private final AtomicInteger count = new AtomicInteger();
//头节点
transient Node<E> head;
//尾节点
private transient Node<E> last;
//出队锁
private final ReentrantLock takeLock = new ReentrantLock();
//如果队列为空，出队就会陷入等待
private final Condition notEmpty = takeLock.newCondition();
//入队锁
private final ReentrantLock putLock = new ReentrantLock();
//如果队列满了，入队就陷入等待
private final Condition notFull = putLock.newCondition();
2.2 存入元素put
public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    
    int c = -1;
    Node<E> node = new Node<E>(e);
    //利用ReentrantLock独占锁来加锁，保证同时只有一个线程来put
    final ReentrantLock putLock = this.putLock;
    //利用AtomicInteger来表示queue中的元素个数
    final AtomicInteger count = this.count;
    //可打断的加锁
    putLock.lockInterruptibly();
    try {
		// private final Condition notFull = putLock.newCondition();
        //如果队列满了，就调用notFull。await()。notFull是putLock的条件变量，当调用notFull.await()会将putLock释放，阻塞在等待队列notFull上
        while (count.get() == capacity) {
            notFull.await();
        }

        //入队,不用获得takeLock，因为与出队操作不涉及共享变量
        //从入队代码可以看出head是一个哨兵节点，不存放任何实际数据
        //last = last.next = node;
        enqueue(node);

        //count++
        c = count.getAndIncrement();
        //如果队列未满，唤醒被阻塞的入队线程
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
        putLock.unlock();
    }
    //如果c == 0，说明入队之前队列为空，唤醒出队的等待线程
    if (c == 0)
        signalNotEmpty();
}

private void signalNotEmpty() {
    final ReentrantLock takeLock = this.takeLock;
    //获取出队锁
    takeLock.lock();
    try {
        //唤醒出队等待线程
        notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
}

取出元素take

public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
        //如果队列为空，放弃takeLock，阻塞在等待队列notEmpty上
        while (count.get() == 0) {
            notEmpty.await();
        }
        //出队
        x = dequeue();
        //count--;
        c = count.getAndDecrement();
        //如果队列不为空，唤醒出队等待线程
        if (c > 1)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    //如果队列不为空，唤醒入队等待线程
    if (c == capacity)
        signalNotFull();
    return x;
}

private E dequeue() {
    //head是哨兵节点，不存放数据，实际的头节点是head.next
    Node<E> h = head;
    //head的next
    Node<E> first = h.next;
    h.next = h;
    //将head踢出
    head = first;
    //first的item才是第一个元素，head是哨兵节点
    E x = first.item;
    first.item = null;
    //从dequeue方法可以看出，queue中始终有一个哨兵head节点，不存储任何数据，queue中第一个元素是head.next
    return x;
}

private void signalNotFull() {
    final ReentrantLock putLock = this.putLock;
    putLock.lock();
    try {
        //唤醒入队等待线程
        notFull.signal();
    } finally {
        putLock.unlock();
    }
}

三、入队出队总结

3.1 入队
方法做法
put如果队列满了，就阻塞，当队列不满的时候，会再执行入队操作
offer如果队列满了，返回false。未满就返回true
add如果队列满了，抛出异常,未满就返回true
3.2 出队
方法做法
take如果队列为空，就阻塞，当队列不空的时候，会再执行出队操作
poll如果队列空了，返回null
peek返回队列首元素，不会出队

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1519667.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

[嵌入式AI从0开始到入土]16_ffmpeg_ascend编译安装及性能测试

[嵌入式AI从0开始到入土]16_ffmpeg_ascend编译安装及性能测试

[嵌入式AI从0开始到入土]嵌入式AI系列教程 注&#xff1a;等我摸完鱼再把链接补上 可以关注我的B站号工具人呵呵的个人空间&#xff0c;后期会考虑出视频教程&#xff0c;务必催更&#xff0c;以防我变身鸽王。 第1期 昇腾Altas 200 DK上手 第2期 下载昇腾案例并运行 第3期 官…
阅读更多...
力扣题目训练（21）

力扣题目训练（21）

2024年2月14日力扣题目训练 2024年2月14日力扣题目训练605. 种花问题617. 合并二叉树628. 三个数的最大乘积289. 生命游戏299. 猜数字游戏149. 直线上最多的点数 2024年2月14日力扣题目训练 2024年2月14日第二十一天编程训练&#xff0c;今天主要是进行一些题训练&#xff0c;…
阅读更多...
2.2 HTML5保留的常用标签

2.2 HTML5保留的常用标签

2.2.1 基础标签 1. 段落标签<p> 段落标签<p>和</p>用于形成一个新的段落&#xff0c;段落与段落之间默认为空一行进行分割。 2. 标题标签<h1>-<h6> HTML5使用<hn>和</hn>来标记文本中的标题&#xff0c;其中n需要替换为数字&#x…
阅读更多...
关于OPC-UA客户端调用服务端方法CallMethod节点的问题

关于OPC-UA客户端调用服务端方法CallMethod节点的问题

在OpcUaClient中可以通过CallMethodByNodeId调用方法节点 //// 摘要:// call a server method//// 参数:// tagParent:// 方法的父节点tag//// tag:// 方法的节点tag//// args:// 传递的参数//// 返回结果:// 输出的结果值public object[] CallMetho…
阅读更多...
淘宝商品详情数据采集（商品属性，规格，价格，详情图等）

淘宝商品详情数据采集（商品属性，规格，价格，详情图等）

淘宝商品详情数据采集是一个涉及多个步骤的过程&#xff0c;主要目的是获取商品的各种详细信息&#xff0c;如商品属性、规格、价格、详情图等。以下是一个基本的采集流程&#xff1a; 确定采集目标&#xff1a;首先&#xff0c;需要明确要采集的淘宝商品范围&#xff0c;例如…
阅读更多...
Filter实现请求日志记录

Filter实现请求日志记录

将锁有得外部访问都记录在日志文件里面&#xff0c;设计这个功能是为了&#xff08;为什么&#xff09;&#xff1a; 1. 在不引入Promentheus进行接口监控时&#xff0c;基于日志文件就可以实现整个项目得监控。 2. 当出现问题时&#xff0c;可以基于此进行流量重放。 效果如…
阅读更多...
数据结构知识点汇总（持续更新版）

数据结构知识点汇总（持续更新版）

数据结构 一、绪论 检测知识&#xff1a; 1.1基本概念 以前的计算机 弹道计算机 现如今 主要运用于非数值的计算 基本概念和术语 数据&#xff1a;是信息的载体&#xff0c;描述客观事物属性的值&#xff0c;字符以及所有能输入到计算机中并被计算机程序识别和处理的符号的…
阅读更多...
如何发布新闻稿？如何让媒体记者报道自己的企业？

如何发布新闻稿？如何让媒体记者报道自己的企业？

目前&#xff0c;很多企业和个人创业者都知道用新闻稿或软文来做宣传&#xff0c;但是一般只可以发布到自己的微信公众号、百家号等自媒体平台&#xff0c;往往收效甚微。有企业找到小马识途营销顾问咨询原因&#xff0c;小马识途营销顾问分析自媒体上发软文效果不明显的原因主…
阅读更多...
NFT交易市场（二）

NFT交易市场（二）

编写脚本文件进行测试 nft合约代码 // SPDX-License-Identifier: MIT pragma solidity ^0.8.24;import "openzeppelin/contracts/interfaces/IERC20.sol"; import "openzeppelin/contracts/interfaces/IERC721.sol";contract Market {//将erc20初始化为一…
阅读更多...
C++进阶之路---手把手带你学习AVL树

C++进阶之路---手把手带你学习AVL树

顾得泉&#xff1a;个人主页 个人专栏&#xff1a;《Linux操作系统》 《C从入门到精通》 《LeedCode刷题》 键盘敲烂&#xff0c;年薪百万&#xff01; 一、AVL树的概念 二叉搜索树虽可以缩短查找的效率&#xff0c;但如果数据有序或接近有序二叉搜索树将退化为单支树&#…
阅读更多...
2024年腾讯云新用户优惠活动4核8G12M配置15个月和一年费用

2024年腾讯云新用户优惠活动4核8G12M配置15个月和一年费用

腾讯云轻量4核8G12M服务器配置446元一年&#xff0c;646元12个月&#xff0c;腾讯云轻量应用服务器具有100%CPU性能&#xff0c;系统盘为180GB SSD盘&#xff0c;12M带宽下载速度1536KB/秒&#xff0c;月流量2000GB&#xff0c;折合每天66.6GB流量&#xff0c;超出月流量包的流…
阅读更多...
访问者模式（Visitor Pattern）

访问者模式（Visitor Pattern）

访问者模式 说明 访问者模式&#xff08;Visitor Pattern&#xff09;属于行为型模式&#xff0c;表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 该模式是将数据结构与数据操作分离的设计模式&#xff0c;是…
阅读更多...
蓝牙系列十三：协议栈L2CAP层

蓝牙系列十三：协议栈L2CAP层

L2CAP 全称为逻辑链路控制与适配协议(Logical Link Control and Adaptation Protocol)&#xff0c;位于基带层之上&#xff0c;将基带层的数据分组交换为便于高层应用的数据分组格式&#xff0c;并提供协议复用和服务质量交换等功能。 该层属于主机的内容&#xff0c;位于HCI层…
阅读更多...
3.3 ss-sp寄存器，栈的push和pop指令

3.3 ss-sp寄存器，栈的push和pop指令

汇编语言 1. 栈 栈是一种具有特殊的访问方式的存储空间它的特殊性就在于&#xff0c;最后进入这个空间的数据&#xff0c;最先出去。即先进后出 1.1 栈的基本操作 入栈&#xff1a;入栈就是将一个新的元素放到栈顶出栈&#xff1a;出栈就是从栈顶取出一个元素栈顶的元素总是…
阅读更多...
电磁场与电磁波——恒定磁场

电磁场与电磁波——恒定磁场

阅读更多...
汽车电子零部件（4）：行泊一体ADAS

汽车电子零部件（4）：行泊一体ADAS

前言： 现阶段智能汽车行业正在大规模力推无限接近于L3的L2++或L2.9自动驾驶量产落地，类似于当初智能手机替换传统手机的行业机会期。智能汽车常见的智能驾驶功能包括： 行车场景：自适应巡航控制ACC；自动变道辅助ALC；交通拥堵辅助TJA；车道居中LCC；领航辅助NOA； 泊车场…
阅读更多...
如何在代理的IP被封后立刻换下一个IP继续任务

如何在代理的IP被封后立刻换下一个IP继续任务

目录 前言 1. IP池准备 2. 使用代理IP进行网络请求 3. 处理IP被封的情况 4. 完整代码示例 总结 前言 当进行某些网络操作时&#xff0c;使用代理服务器可以帮助我们隐藏真实IP地址以保护隐私&#xff0c;或者绕过一些限制。然而&#xff0c;经常遇到的问题是代理的IP可能…
阅读更多...
AI新工具(20240313) 用户输入提示词创建任何GIF； 将任意人脸图片转换为另一幅图像的模型

AI新工具(20240313) 用户输入提示词创建任何GIF； 将任意人脸图片转换为另一幅图像的模型

✨ 1: GifShift 用户输入提示词创建任何GIF gifshift是一种工具&#xff0c;可以帮助用户创建任何GIF的新版本。使用gifshift的步骤如下&#xff1a; 上传一个GIF文件或者使用库中的一个GIF。 提供您想要的场景描述&#xff0c;最好选择一些具有代表性的角色&#xff0c;并进…
阅读更多...
Android cmdline tools安装

Android cmdline tools安装

打开AS 进入SDK Tools 看到了吗?那个打着勾的就是
阅读更多...
从零开始搭建医保购药APP：技术选择与开发流程

从零开始搭建医保购药APP：技术选择与开发流程

医保购药APP作为一种创新的医疗服务工具&#xff0c;为用户提供了便捷的医保购药流程&#xff0c;同时也为医疗机构提供了更高效的管理和服务方式。今天小编将为大家讲解如何从零开始搭建一款医保购药APP&#xff0c;包括技术选择和开发流程。 一、技术选择 在搭建医保购药APP…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023