十四、LinkedBlockingQueue

于 2023-05-31 22:44:07 发布
阅读量103 收藏
点赞数
分类专栏： Java-高并发 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45128800/article/details/130978409
版权

一、概念

  • 底层是一个Node节点组成的一个单向链表
  • 基于ReentrantLock实现的，读写分离的阻塞队列，所以说LinkedBlockingQueue的吞吐量是要比ArrayBlockingQueue高的
  • 两把锁（ReentrantLock，只能是非公平的），一把读锁，一把写锁，所以说，读读互斥，写写互斥，读写不互斥
  • 其实这个的读写也用的是Condition，notEmpty控制读，notFull控制写
  • 可以用户自定义链表长度（所以严格意义来说，不是一个无界队列）

二、应用

写操作

  • add(E e)
    • 队列中添加数据，如果队列满了， 会抛出异常new IllegalStateException(“Queue full”)
      底层调用offer方法
    • 返回值boolean
  • offer(E e)
    • 队列中添加数据，如果队列满了，不会抛出异常，会返回false
    • 返回值boolean
  • offer(E e, long timeout, TimeUnit unit)
    • 队列中添加数据，如果队列满了，会阻塞当前线程timeout时间
    • 返回值boolean
  • put(E e)
    • 队列中添加数据，如果队列满了，会阻塞当前线程，直到有数据或者被打断
    • 无返回值

读操作

  • remove()
    • 获取队列中数据，如果队列中没有数据，则抛出异常throw new NoSuchElementException()
      底层调用poll方法
    • 返回值E
  • poll()
    • 获取队列中数据，如果队列中没有数据，则返回null
    • 返回值E
  • poll(long timeout, TimeUnit unit)
    • 获取队列中数据，如果队列中没有数据，则阻塞当前线程timeout时间
    • 返回值E
  • take()
    • 获取队列中数据，如果队列中没有数据，会阻塞当前线程，直到有数据
    • 返回值E

三、源码（jdk1.8）

重要属性

static class Node<E> {
    E item;
    Node<E> next;
    Node(E x) { item = x; }
}

// 容量，即链表长度
private final int capacity;

// 链表中实际数据数量，用Ato，就保证了读写的时候共享
private final AtomicInteger count = new AtomicInteger();

// 头节点
transient Node<E> head;

// 尾节点
private transient Node<E> last;

// 读锁，以及读用的Condition
private final ReentrantLock takeLock = new ReentrantLock();
private final Condition notEmpty = takeLock.newCondition();

// 写锁，以及写用的Condition
private final ReentrantLock putLock = new ReentrantLock();
private final Condition notFull = putLock.newCondition();

构造方法

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);
}

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();
            if (n == capacity)
                throw new IllegalStateException("Queue full");
            enqueue(new Node<E>(e));
            ++n;
        }
        count.set(n);
    } finally {
        putLock.unlock();
    }
}

offer(E e)

public boolean offer(E e) {
    if (e == null) throw new NullPointerException();
    // 拿到链表中的实际数据量
    final AtomicInteger count = this.count;
    // 如果实际数据量跟容量相等，则插入失败，返回false
    if (count.get() == capacity)
        return false;
    int c = -1;
    // 构建一个新的Node
    Node<E> node = new Node<E>(e);
    // 获取写锁
    final ReentrantLock putLock = this.putLock;
    putLock.lock();
    try {
        // 如果实际数据量小于容量，则插入
        if (count.get() < capacity) {
            // 插入链表
            enqueue(node);
            // 先将count赋值给c，然后再将count+1
            c = count.getAndIncrement();
            // 判断是不是还有容量，有的话，唤醒别的存放线程
            if (c + 1 < capacity)
                notFull.signal();
        }
    } finally {
        // 释放锁
        putLock.unlock();
    }
    // 如果C==0，那么就证明以前链表是个空的，可能会有读线程阻塞，则唤醒读线程
    if (c == 0)
        signalNotEmpty();
    return c >= 0;
}

private void enqueue(Node<E> node) {
    // 先将尾节点的next指向新节点，然后将last设置为新节点
    last = last.next = node;
}

add(E e)

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

offer(E e, long timeout, TimeUnit unit)

public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    long nanos = unit.toNanos(timeout);
    int c = -1;
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;
    putLock.lockInterruptibly();
    try {
        while (count.get() == capacity) {
            if (nanos <= 0)
                return false;
            nanos = notFull.awaitNanos(nanos);
        }
        enqueue(new Node<E>(e));
        c = count.getAndIncrement();
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
        putLock.unlock();
    }
    if (c == 0)
        signalNotEmpty();
    return true;
}

put(E e)

public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    int c = -1;
    Node<E> node = new Node<E>(e);
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;
    putLock.lockInterruptibly();
    try {
        while (count.get() == capacity) {
            notFull.await();
        }
        enqueue(node);
        c = count.getAndIncrement();
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
        putLock.unlock();
    }
    if (c == 0)
        signalNotEmpty();
}

poll()(E e)

public E poll() {
    // 获取当前链表的实际数据量
    final AtomicInteger count = this.count;
    // 如果count == 0, 则证明没有数据
    if (count.get() == 0)
        return null;
    E x = null;
    int c = -1;
    // 获取读锁
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        // 如果count > 0，则证明有数据
        if (count.get() > 0) {
            // 获取数据
            x = dequeue();
            // 先拿到count的值赋给c，然后将count -1
            c = count.getAndDecrement();
            // 如果说c>1，则证明以前就有数据，唤醒阻塞的读线程
            if (c > 1)
                notEmpty.signal();
        }
    } finally {
        // 释放锁
        takeLock.unlock();
    }
    // 如果c==容量，则证明以前肯定是放满链表了，然后阻塞了哈，然后现在你已经拿走了一个，所以就唤醒阻塞的写线程
    if (c == capacity)
        signalNotFull();
    return x;
}

private E dequeue() {
    // 拿到head
    Node<E> h = head;
    // 将head的next拿到
    Node<E> first = h.next;
    // 然后将head的next指向自己，方便GC
    h.next = h; // help GC
    // 将head指向 head的next
    head = first;
    // 拿到first里面的值
    E x = first.item;
    // 将这个frist的item设置为null
    first.item = null;
    // 返回值
    return x;
}

remove()

public E remove() {
    E x = poll();
    if (x != null)
        return x;
    else
        throw new NoSuchElementException();
}

poll(long timeout, TimeUnit unit)

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
    E x = null;
    int c = -1;
    long nanos = unit.toNanos(timeout);
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
        while (count.get() == 0) {
            if (nanos <= 0)
                return null;
            nanos = notEmpty.awaitNanos(nanos);
        }
        x = dequeue();
        c = count.getAndDecrement();
        if (c > 1)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        signalNotFull();
    return x;
}

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) {
            notEmpty.await();
        }
        x = dequeue();
        c = count.getAndDecrement();
        if (c > 1)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        signalNotFull();
    return x;
}

四、总结流程（个人总结，可能有误）

在这里插入图片描述

  • 千万不要有一个想法：如果读和写在同一个Node咋办
    • 这是不可能的，一定是写了一个Node，才会有读的线程去消费。看源码
    • 用一个Ato的count去控制的啊

  1. offer/put

    • offer：
      • 判断当前链表数据量跟容量是否相等
        • 相等，则证明满了，返回false
        • 不相等：
          • 获取写锁
          • 则将当前数据封装成Node，插入到链表尾端
          • 判断如果的count < 容量，则唤醒其他写线程
          • 释放写锁
          • 判断如果count == 0，则证明，以前有其他读线程在阻塞，则唤醒其他读线程
    • put：
      • 判断当前链表数量 == 0
        • 相等，则证明没有数据，返回null
        • 不相等：
          • 获取读锁
          • DCL判断当前链表数量 > 0，如果不是的话就直接返回null
          • 获取数据
          • 判断如果的count > 0，则唤醒其他读线程
          • 释放读锁
          • 判断如果count == 链表长度，则以前肯定是有些线程在阻塞，则唤醒其他写线程

  2. offer(E e, long timeout, TimeUnit unit)/poll(long timeout, TimeUnit unit)

    • offer(E e, long timeout, TimeUnit unit)
      • 获取写锁
      • 判断当前链表数据量跟容量是否相等
        • 相等，则Condition挂起线程timeout时间，等待被唤醒或者打断，然后执行不相等中的插入逻辑
        • 不相等：
          • 则将当前数据封装成Node，插入到链表尾端
          • 判断如果的count < 容量，则唤醒其他写线程
          • 释放写锁
          • 判断如果count == 0，则证明，以前有其他读线程在阻塞，则唤醒其他读线程
    • poll(long timeout, TimeUnit unit)
      • 获取读锁
      • 判断当前链表数量 == 0
        • 相等，则Condition挂起线程timeout时间，等待被唤醒或者打断，然后执行不相等中的获取逻辑
        • 不相等
          • 获取数据
          • 判断如果的count > 0，则唤醒其他读线程
          • 释放读锁
          • 判断如果count == 链表长度，则以前肯定是有些线程在阻塞，则唤醒其他写线程

  3. put(E e)/take()

    • put(E e)
      • 获取写锁
      • 判断当前链表数据量跟容量是否相等
        • 相等，则Condition挂起线程，等待被唤醒或者打断，然后执行不相等中的插入逻辑
        • 不相等：
          • 则将当前数据封装成Node，插入到链表尾端
          • 判断如果的count < 容量，则唤醒其他写线程
          • 释放写锁
          • 判断如果count == 0，则证明，以前有其他读线程在阻塞，则唤醒其他读线程
    • take()
      • 获取读锁
      • 判断当前链表数量 == 0
        • 相等，则Condition挂起线程，等待被唤醒或者打断，然后执行不相等中的获取逻辑
        • 不相等：
          • 获取数据
          • 判断如果的count > 0，则唤醒其他读线程
          • 释放读锁
          • 判断如果count == 链表长度，则以前肯定是有些线程在阻塞，则唤醒其他写线程
残酷天使的行动纲领eva
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java后端面试题大纲（涵盖了百分之九十的考点）.pdf
04-19
- 主要有`ArrayBlockingQueue`、`LinkedBlockingQueue`等实现。 13. **ThreadLocal的作用** - `ThreadLocal`提供了一个线程局部变量的解决方案，每个线程都有独立的变量副本。 - 避免了通过参数传递变量的麻烦，...
Java堵塞队列--LinkedBlockingQueue
Artisan_w
10-31 336
无参定义，默认构造方法，队列容量为Integer.MAX_VALUE指定队列容量的构造方法基于集合构建队列，默认容量为Integer.MAX_VALUEtry {int n = 0;++n;可以看到，第一第三种方式都是设置大小为Integer.MAX_VALUE，这容易导致堆栈溢出，因此一般建议使用自定义大小的方式来定义。
多线程的死锁
m0_69715573的博客
07-25 643
线程的应用
阿里面试官常问：阻塞队列ArrayBlockingQueue与LinkedBlockingQueue的问题
Java后端架构V
05-18 328
这里我们把上述操作进行分类：（1）插入方法（2）删除方法（3）检查方法。
BlockingQueue(堵塞式队列）
没伞的孩子努力奔跑
08-23 265
一 简单讲解 BlockingQueue使用一种FIFO算法，先进先出，体现出公平。 如果查询多，就使用数组结构 如果增删多，就使用链表结构 常用的场景： 连接池和线程池 二 为什么会堵塞 如果队列满了，提供put（）方法，就进行堵塞，线程会堵塞那里，直到线程空。 如果队列空了，提供take()方法，线程就堵塞那里，取不出来。 案列： package demo; import java.util.concurrent.ArrayBlockingQueue; public class
Executors使用不当引起的内存泄漏
一个程序员的成长
09-08 1817
线上服务内存溢出这周刚上班突然有一个项目内存溢出了，排查了半天终于找到问题所在，在此记录下，防止后面再次出现类似的情况。先简单说下当出现内存溢出之后，我是如何排查的，首先通过jstack...
java-阻塞队列BlockingQueue
热门推荐
心猿意碼
04-18 1万+
一、概述 队列：先进先出。包含固定长度队列和不固定长度队列 什么是可阻塞队列：队列满了添加线程会阻塞等待，队列空了获取线程也会阻塞等待。非阻塞队列则会直接报错。 BlockingQueue支持两个附加操作的Queue：1）当Queue为空时，获取元素线程被阻塞直到Queue变为非空；2）当Queue满时，添加元素线程被阻塞直到Queue不满。BlockingQueue不允许元素为null，如...
java多线程模拟抢红包功能
08-28
四、LinkedBlockingQueue LinkedBlockingQueue 是 Java 提供的一种阻塞队列实现，用于存储红包。在本文中，我们使用 LinkedBlockingQueue 来存储红包，抢红包的人可以从队列中取出红包。 五、线程安全 线程安全是...
java面试题2024资源下载
最新发布
06-27
#### 二十四、如何确定核心线程数 - **经验法则**： - 通常设置为核心数+1。 - **性能测试**： - 通过实际运行测试来确定最优的核心线程数。 #### 二十五、runnable与callable的区别 - **return类型**： - ...
JUC多线程及高并发1
08-03
阻塞队列在多线程间提供高效的数据传递，如ArrayBlockingQueue、LinkedBlockingQueue等。它们提供put和take方法，当队列满或空时，会阻塞相应的操作，减少了锁的使用。 八、线程池 ThreadPoolExecutor是Java的...
multithread_design
05-21
3. BlockingQueue：用于线程间通信的数据结构，如ArrayBlockingQueue、LinkedBlockingQueue等，常用于生产者消费者模型。 六、并发工具类 1. CountDownLatch：计数器，用于同步多个线程，当计数到零时所有线程才能...
关于java中阻塞队列（LinkedBlockingQueue）中任务执行失败后的重试机制几种方案
yinyuehuiok的专栏
08-06 3185
晚上在完善
多线程系列：附、LinkedBlockingQueue 引发的一次线上事故
BigBug_500的博客
03-22 2172
总结：    空闲线程从 BlockingQueue 中获取任务时，是通过信号量的方式，每次唤醒一个线程去取任务，所以，当向线程池提交任务过快，每次唤醒一个线程去执行任务处理不过来时，便会执行任务拒绝策略。 业务场景：    对账进程需要下载 某一时间段 的 n个账号 的第三方账单，第三方账单中数据量大，需要控速入库，入库完一组数据，再去下载第二组账单。 线程池配置： @Bean public ThreadPoolTaskExecutor cpuThreadPool() { ThreadPoolTa
记录一下 ArrayBlockingQueue 消息堆积的问题
风团团
03-24 383
由于之前这个系统的日志记录是被领导要求写表的，在不影响系统性能的前提下，日志的入库操作肯定是要改成异步进行的，当时利用 ArrayBlockingQueue+线程+AOP 简单的去实现了一下，但是初版代码测试下来发现了一个很严重的问题，就是日志丢失的问题，本文由此而来。
JAVA并发队列
GeeLoong`s Blog
08-24 260
Java并发队列 在并发队列上JDK提供了两套实现： 一个是以ConcurrentLinkedQueue为代表的高性能队列； 一个是以BlockingQueue接口为代表的阻塞队列； 无论哪种都继承自Queue。 一、ConcurrentLinkedQueue 定义 ConcurrentLinkedQueue: 是一个适用于高并发场景下的队列，通过无锁的方式，实现了高并发状态下...
JDK8系列：阻塞队列 之 LinkedBlockingDeque（双向阻塞队列）源码解析
啦卡的博客
11-07 422
1、LinkedBlockingDeque 简介 LinkedBlockingDeque是一个基于链表的双端阻塞队列。和LinkedBlockingQueue类似，区别在于该类实现了Deque接口，而LinkedBlockingQueue实现了Queue接口。该类的继承关系如下图： 容量问题 LinkedBlockingDeque是一个可选容量的阻塞队列，如果没有设置容量，那么容量将是Int的最大值。 底层数据结构 LinkedBlockingDeque的底层数据结构是一个双端队列，该队列使用链.
集合概述03
weixin_44251806的博客
08-25 271
Stack,Queue
LinkedBlockingQueue
zhu119064177的博客
05-02 316
LinkedBlockingQueue是基于链表的阻塞式队列；其默认初始化长度为Integer.MAX_VALUE，也可以指定长度；public LinkedBlockingQueue() { this(Integer.MAX_VALUE);// MAX_VALUE = 0x7fffffff;} public LinkedBlockingQueue(int capacity) { ...
LinkedBlockingQueue阻塞队列详解
weixin_30697239的博客
04-22 198
主要api java.util.concurrent包下的新类。LinkedBlockingQueue就是其中之一，是一个阻塞的线程安全的队列，底层采用链表实现。 LinkedBlockingQueue构造的时候若没有指定大小，则默认大小为Integer.MAX_VALUE，当然也可以在构造函数的参数中指定大小。LinkedBlockingQueue不接受null。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值