队列：LinkedBlockingQueue源码解析

最新推荐文章于 2024-03-11 10:39:02 发布
最新推荐文章于 2024-03-11 10:39:02 发布
阅读量447 收藏 1
点赞数 1
分类专栏： Java源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jakob_Hu/article/details/102495485
版权

LinkedBlockingQueue源码解析


队列是很重要的API，线程池、读写锁、消息队列等技术和框架的底层原理都是队列，是很多高级API的基础。

LinkedBlockingQueue可以理解为一个典型的生产者-消费者模型。

1.整体架构

LinkedBlockingQueue，链表阻塞队列，底层的数据结构时链表，且队列是可阻塞的。
image

Queue接口和BlockingQueue接口

从类关系图中可以看出两条线路，

线路1
AbstractQueue --> AbstractCollection --> Collection --> Iterable

这条路线主要是想复用Collection和迭代器的一些操作。

线路2
BlockingQueue --> Queue -->Collection

Queue是最基础的接口，几乎所有队列实现类都实现这个接口，该接口定义了队列的三类基本操作，

  • 新增操作
    add方法队列满时抛出异常
    offer方法队列满时返回false
  • 查看并删除操作
    remove方法队列为空时返回false
    poll方法队列为空时返回null
  • 只查看但不删除操作
    element方法队列为空时抛出异常
    peek方法队列为空时返回null

BlockingQueue在Queue的基础上添加了阻塞的概念，如一直阻塞或阻塞指定时间，

操作类型抛异常特殊值阻塞阻塞一段时间
新增直至队列已满addoffer返回falseputoffer设置超时，超时返回false
弹出队列头至队列为空无remove返回false；poll返回nulltakepoll设置超时，超时返回null
查看队列头但不弹出elementpeek返回null无无

类注释

  1. 基于链表的阻塞队列，底层数据结构是链表
  2. 链表维护先入先出队列，新元素添加到队尾，获取元素时从头部取出
  3. 链表的大小在初始化时候可以设置，默认是Integer的最大值
  4. 可以使用Collection和Iterable的所有操作

内部结构

LinkedBlockingQueue可以分为三个部分，存储链表+锁+迭代器，

// 链表节点
static class Node<E> {
    E item;

    Node<E> next;

    Node(E x) { item = x; }
}

// 链表容量，默认情况下是 Integer.MAX_VALUE
private final int capacity;

// 使用原子性的Integer类对象记录链表元素数目
private final AtomicInteger count = new AtomicInteger();

// 链表头
transient Node<E> head;

// 链表尾
private transient Node<E> last;

// 获取元素时候的锁，take和poll方法会用到
private final ReentrantLock takeLock = new ReentrantLock();

// 获取元素时的条件队列，可以理解为 等待链表not empty时才获取元素
private final Condition notEmpty = takeLock.newCondition();

// 添加元素时候的锁，put和offer方法会用到
private final ReentrantLock putLock = new ReentrantLock();

// 添加元素时的条件队列，可以理解为 等待链表not Full时才添加元素
private final Condition notFull = putLock.newCondition();

// 内部实现的迭代器
private class Itr implements Iterator<E> {
	......
}

三种结构各司其职，

  1. 链表作用是保存当前节点，节点使用了泛型，所以节点中的数据可以是任意的对象。
  2. 锁有take和put锁，目的是保证队列操作时线程安全，同时take和put操作可以同时进行，互不影响。

初始化

LinkedBlockingQueue有三种初始化方式，

// 无参数初始化，默认容量是Integer.MAX_VALUE
public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);	// 此处调用的是指定容量初始化的构造方法（见下）
}

// 指定容量初始化
public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    last = head = new Node<E>(null);	// 注意，head节点一定是固定的值为null的节点对象，保证了不会空指针异常
}

// 使用集合对象初始化
public LinkedBlockingQueue(Collection<? extends E> c) {
    this(Integer.MAX_VALUE);
    final ReentrantLock putLock = this.putLock;
    putLock.lock(); // Never contended, but necessary for visibility
    try {
        int n = 0;
        for (E e : c) {
            if (e == null)
                throw new NullPointerException();	// 集合类元素不能为null
            if (n == capacity)
                throw new IllegalStateException("Queue full");
            enqueue(new Node<E>(e));
            ++n;
        }
        count.set(n);
    } finally {
        putLock.unlock();
    }
}

初始化源码中包含的信息，

  1. 初始化时容量大小不影响性能，只影响以后的使用，初始化队列太小会导致过早报出IllegalStateException异常
  2. 源码中for循环的形式并不优雅，添加一个元素后检查是否超过capacity是一种低效的方式。完全可以先得到集合对象的size，直接判断是否与设定的capacity冲突。

2.源码解析

入队和出队操作

队列是先进先出的结构，入队元素会被添加到队尾，出队元素是队列头部元素。分别对应于enqueue和dequeue方法。

1) enqueue方法

入队方法很简单，在队尾添加节点后将last指针指向新加入的节点对象。

private void enqueue(Node<E> node) {
    last = last.next = node;
}

初始化方法中，last指针首先会知道一个item为null的节点对象上，因此在添加节点的过程中不会出现空指针异常。

2) dequeue方法

出队每次需要将队列头部元素取出，注意需要保证head指针始终指向的是item为null的节点。

private E dequeue() {
    Node<E> h = head;
    Node<E> first = h.next;	// 此时h是初始化时创建的item为null的节点，first指向的是实际的队列头部
    h.next = h; // help GC
    head = first;	// head指针指向队列头部节点
    E x = first.item;
    first.item = null;	// 返回头部节点的item值，并将头部节点的item设置为null，成为新的head节点
    return x;
}

新增节点操作

1) add方法

add方法在容量达到capacity时会抛出异常，

public boolean add(E e) {
    if (offer(e))
        return true;
    else
        throw new IllegalStateException("Queue full");
}

可见该方法底层调用的是offer方法，通过offer方法的返回值判断是否添加成功，如果添加失败则会抛出异常。

2) offer方法

offer方法不会抛出异常，而是在添加成功后返回true，反之，返回false。

public boolean offer(E e) {
    if (e == null) throw new NullPointerException();
    final AtomicInteger count = this.count;
    if (count.get() == capacity)	// 队列满了返回false
        return false;
        
    int c = -1;		// 注意这里 c初始化值为是-1
    Node<E> node = new Node<E>(e);
    final ReentrantLock putLock = this.putLock;	// 争取到put锁后，上锁
    putLock.lock();
    try {
        if (count.get() < capacity) {
            enqueue(node);
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();	// 如果队列未满，添加元素后count值值赋予c变量，之后增加
        }
    } finally {
        putLock.unlock();
    }
    if (c == 0)
        signalNotEmpty();	// 如果c从-1到0说明是第一次加入元素，队列从空变为非空，唤醒put等待队列中的线程
    return c >= 0;
}

private void signalNotEmpty() {
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
}

3) put方法

public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    // Note: convention in all put/take/etc is to preset local var
    // holding count negative to indicate failure unless set.
    int c = -1;
    Node<E> node = new Node<E>(e);
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;
    putLock.lockInterruptibly();
    try {
        // 如果队列已满则阻塞，可简单记忆为 wait not full，等待未满的过程
        while (count.get() == capacity) {
            notFull.await();
        }
        enqueue(node);
        c = count.getAndIncrement();
        if (c + 1 < capacity)
            notFull.signal();	// 添加后如果还未满，可尝试唤醒另一个put等待队列中的对象
    } finally {
        putLock.unlock();
    }
    if (c == 0)
        signalNotEmpty();
}

三种添加元素的方法进行如下总结，

  1. 添加元素的第一步是上锁，保证线程安全
  2. 新增数据直接添加到队尾即可
  3. 新增数据时，如果容量满了，则当前线程阻塞，直至队头元素被取出使得队列中存在空位。阻塞是通过锁实现的，具体原理也是等待队列，会在以后锁相关的笔记中说明
  4. 添加元素成功后，如果队列未满，会尝试唤醒putLock的等待线程；同时，如果队列不为空，会唤醒takeLock的等待线程。保证一旦满足put或take的条件，就能够唤起等待线程，不会浪费时间。

offer方法可以设置阻塞一定时间，具体原理与put方法相同，只是在一定时间范围内阻塞，
image

删除节点操作

队列的删除节点操作返回的是队列头节点的值，但是具体返回形式有两种，一种是返回值的同时删除头节点，另一种是返回值但是不删除节点。

删除数据关注两点，

  1. 删除原理
  2. 查看并删除和查看不删除在实现方式上的区别

查看并删除

1) take方法(阻塞)
public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
        while (count.get() == 0) {	// 如果队列为空，则阻塞，wait not empty
            notEmpty.await();
        }
        x = dequeue();
        c = count.getAndDecrement();
        if (c > 1)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        signalNotFull();
    return x;
}
  1. 先上锁
  2. 如果队列为空，则阻塞，直至队列非空；反之，使用dequeue方法删除队头节点，并返回队头节点的值
  3. 如果满足put或take的条件，会尝试唤醒等待队列中的线程
2) poll方法(非阻塞)
public E poll() {
    final AtomicInteger count = this.count;
    if (count.get() == 0)	// 如果队列为空直接返回null
        return null;
    E x = null;
    int c = -1;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        if (count.get() > 0) {
            x = dequeue();
            c = count.getAndDecrement();
            if (c > 1)
                notEmpty.signal();
        }
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        signalNotFull();
    return x;
}

与take方法相比，不存在阻塞过程。

查看但不删除—peek方法

public E peek() {
    if (count.get() == 0)	// 队列为空则返回null
        return null;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        Node<E> first = head.next;
        if (first == null)
            return null;
        else
            return first.item;	// 获取队头节点的item值并返回
    } finally {
        takeLock.unlock();
    }
}

该过程不涉及使用dequeue删除对头节点。

总结

LinkedBlockingQueue可以应用到多线程环境中，如消费者-生产者模型。队列本身也是很重要的数据结构。

Jakob_Hu
关注
专栏目录
第十三篇：LinkedBlockingQueue的源码解析（基于JDK1.8）
码农飞哥
02-09 1814
LinkedBlockingQueue是一个基于链表实现的阻塞queue,它的性能好于ArrayBlockingQueue,但是差于ConcurrentLinkedQueue；并且它非常适于生产者消费者的环境中，比Executors.newFixedThreadPool()就是基于这个队列的，使用LinkedBlockingQueue时一定要设置容量，不然会有内存溢出的风险。
LinkedBlockingQueue api 详解
小白爱学习的专栏
07-27 1192
今天时间学习LinkedBlockingQueueapi，该类是JUC原子包中的类，通过单元测试代码把所有public api方法跑了一遍，大致了解了底层实现，初学乍练，有很多一知半解的地方，待后续有了深入理解再来补充 package test.java.util.concurrent; import java.util.HashSet; import java.util.Iterator; import java.util.Set; import java.util.Spliterator; i.
LinkedBlockingQueue的api
越自律越自由
12-26 5983
/** * add方法在添加元素的时候，若超出了度列的长度会直接抛出异常： * put方法，若向队尾添加元素的时候发现队列已经满了会发生阻塞一直等待空间，以加入元素。 * offer方法在添加元素时，如果发现队列已满无法添加的话，会直接返回false。 * */ public class Producer implements Runnable { protected Bloc
BlockingQueue - LinkedBlockingQueue常用API
javaThinker的专栏
07-06 634
Level. 放入 取出 1 add 队列满？异常：return true remove 队列空？异常：return head 2 offer 队列满？return false：return true poll 队列空？return null：return head 3 put 队列满？阻塞：return [void] take 队列空？阻塞：return head add、offer、put BlockingQueue 的put、offer、add区别，看注释： Block...
【LinkedBlockingQueue的API】 1.offer(添加数据) 2.isEmpty+ drainTo(批量消费) 3.poll 4.take
focus-unchanged-thing
09-21 2456
1)阻塞队列： 线程级别的场景 ArrayBlockingQueue LinkedBlockingQueue DelayQueue：优先级的无界阻塞队列 SynchrousQueue 。。。7种 1.责任链 2.方法--》实现生产者 消费者模型---》实现顺序处理 remove(删除) poll(取元素， 没有元素则返回null) take(队列为空则阻塞) add(添加元素到队列，满了以后会抛出异常) of......
LinkedBlockingQueue的3对易混API
MJ的博客
02-23 168
目录 3对API结论 放入测试 取出测试 3对API结论 Level. 放入 取出 1 add 队列满？异常：return true remove 队列空？异常：return head 2 offer 队列满？return false：return true poll 队列空？return null：return head 3 put 队列满？阻塞：return [void] tak...
【源码篇】LinkedBlockingQueue源码超详细解读
和我一起学习吧
04-21 1017
LinkedBlockingQueue和它的名字一样，它是一个由链表实现的有界阻塞队列，该队列按照先进先出的逻辑对队列进行排序。该队列使用了两把锁分别控制放入和取出，大大提高了并发效率。
阻塞队列之LinkedBlockingQueue - 源码解析（一）
nbdclw的博客
08-27 159
一、概述 LinkedBlockingQueue是一个单向链表的阻塞队列，FIFO队列，是无界队列，当前如果初始化的时候指定大小，也可以是有界队列。 二、思想 LinkedBlockingQueue思想： 数据结构是单项链表 生产者和消费者使用同一个队列 生产者和消费者分别使用自己的锁，读写分离，生产者使用putLock，消费者使用takeLock 生产者只有在队列未满时生产，队列满时生产者线程就进行阻塞 消费者只有在队列有数据时消费，队列没有数据消费者线程就进行阻塞 三、源码解析 撤销：Ctrl/Co
LinkedBlockingQueue源码解析与使用指南
LinkedBlockingQueue是Java中提供的一个基于链表的阻塞队列实现。它具有先进先出的特性，非常适合作为生产者-消费者模式中的缓冲区使用。在多线程编程中，使用LinkedBlockingQueue可以有效地实现线程间的安全通信和...
线程基础—并发容器：LinkedBlockingQueue
wolfcode_cn的博客
02-15 1228
本文作者：王一飞，叩丁狼高级讲师。原创文章，转载请注明出处。 #####概念 LinkedBlockingQueue按照api解释：一个基于链表而实现的有界阻塞队列。遵循先进先出原则，由队头入列，再从队尾出列。具体操作上跟ArrayBlockingQueue类似，区别在于底层维护数据上，LinkedBlockingQueue底层是一个链接，而ArrayBlockingQueue是一个数组。 ...
Java阻塞队列，BlockingQueue常用Api介绍
最新发布
十三月的博客
03-11 79
在 Java 中，阻塞队列是一种特殊的队列数据结构，它具有阻塞操作的特性，即当队列为空时，获取元素的操作会被阻塞；当队列已满时，添加元素的操作也会被阻塞。Java 提供了包中的接口，以及其实现类，用于实现阻塞队列。这些阻塞队列都实现了接口，提供了诸如puttakeofferpoll等方法，可以实现阻塞的添加和获取元素操作。
Java并发系列源码分析（七）--LinkedBlockingQueue
一蓑烟雨任平生
02-11 91
LinkedBlockingQueue是一个阻塞的有界队列,底层是通过一个个的Node节点形成的链表实现的,链表队列中的头节点是一个空的`Node`节点,在多线程下操作时会使用ReentrantLock锁来保证数据的安全性,并使用ReentrantLock下的Condition对象来阻塞以及唤醒线程。
深入理解LinkedBlockingQueue
wds的博客
03-13 2万+
说明 通过阅读源码，了解LinkedBlockingQueue的特性。本文基于JDK1.7源码 正文 通过查询API对LinkedBlockingQueue特点进行简单的了解： LinkedBlockingQueue是一个基于已链接节点的，范围任意的blocking queue 此队列按FIFO（先进先出）排序元素 新元素插入到队列的尾部，并且队列获取操作会获得位于队列头部的元素 链...
深入探究LinkedBlockingQueue、ArrayBlockingQueue、PriorityBlockingQueue、DelayQueue源码
沐雨橙风ιε的博客
08-19 288
深入探究LinkedBlockingQueue、ArrayBlockingQueue、PriorityBlockingQueue、DelayQueue源码
2020-08-31-LinkedBlockingQueue详解
weixin_43395106的博客
08-31 1561
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录说明一、解读(1)LinkedBlockQueue(2)节点内部类Node(2)LinkedBlockingQueue的属性(2)LinkedBlockingQueue的构造函数(2)LinkedBlockingQueue的添加方法(2)LinkedBlockingQueue的取出方法获取队列当前及剩余容量 说明 通过阅读源码,了解LinkedBlockQueue的特性,本文基于JDK1.7源码 一、解读 通过查询API对Lin
【细谈Java并发】谈谈LinkedBlockingQueue
热门推荐
颤抖吧腿子
10-26 12万+
最近在看concurrent包的知识，看到LinkedBlockingQueue，发现一篇好文推荐给大家。 原文地址：【细谈Java并发】谈谈LinkedBlockingQueue 1、简介 上篇我们介绍了ArrayBlockingQueue的相关方法的原理，这一篇我们来学习一下ArrayBlockingQueue的“亲戚” LinkedBlockingQueue。在集合框架里，想必大家都用过Ar...
LinkedBlockingQueue讲解及源码解析
qq_38306425的博客
11-10 3521
1.概述 自java5后，jdk增加了concurrent包，concurrent中的BlockingQueue，也就是堵塞队列，BlockingQueue只是一个接口，jdk为其提供了丰富的实现类，适用于不同的场景，这篇讲的是LinkedBlockingQueue。 2.简介 LinkedBlockingQueue继承了AbstractQueue类和实现了BlockingQueue接口，是一个基于内部链表的有界队列，如果初始化不设置大小，默认设置大小为Integer.MAX_VALUE（无界队列）。锁是基
【第十九篇】阻塞队列之LinkedBlockingQueue原理简析【重点】
sunnyday0426的博客
03-02 5150
1.1 概要 本文主要是对Java并发中阻塞队列的LinkedBlockingQueue进行深入分析。   阻塞队列与我们平常接触的普通队列(LinkedList或ArrayList等)的最大不同点，在于阻塞队列的阻塞添加和阻塞删除方法。 阻塞添加 所谓的阻塞添加是指当阻塞队列元素已满时，队列会阻塞加入元素的线程，直队列元素不满时才重新唤醒线程执行元素加入操作。 阻塞删除 阻塞删除是指在队列元素为空时，删除队列元素的线程将被阻塞，直到队列不为空再执行删除操作(一般都会返回被删除的元素) 1.2 原理
并发队列 ConcurrentLinkedQueue 及 BlockingQueue 接口实现的四种队列
二一点
03-29 1万+
队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。在队列这种数据结构中，最先插入的元素将是最先被删除的元素；反之最后插入的元素将是最后被删除的元素，因此队列又称为“先进先出”（FIFO—first in first out）的线性表。在并发队列上JDK提供了两...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值