Java堵塞队列--LinkedBlockingQueue

2023-11-01 02:44

本文主要是介绍Java堵塞队列--LinkedBlockingQueue,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

参考来源:https://juejin.cn/post/7000515796053000228

Java堵塞队列–LinkedBlockingQueue

LinkedBlockingQueue是基于单向链表的阻塞队列,先进先出的顺序,支持多线程并发操作。LinkedBlockingQueue可认为是无界队列,多用于任务队列。
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);}

基于集合构建队列,默认容量为Integer.MAX_VALUE

    public LinkedBlockingQueue(Collection<? extends E> c) {this(Integer.MAX_VALUE);final ReentrantLock putLock = this.putLock;putLock.lock(); // Never contended, but necessary for visibilitytry {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();}}

可以看到,第一第三种方式都是设置大小为Integer.MAX_VALUE,这容易导致堆栈溢出,因此一般建议使用自定义大小的方式来定义

基本属性

在LinkedBlockingQueue中定义的变量及其含义如下:
capacity:该变量表示队列的容量,设置该值则变为一个有界队列;如果不设置的话默认取值为Integer.MAX_VALUE,也可以认为是无界队列
count:当前队列中元素的数量
head和last:分别表示链表的头尾节点,其中头结点head不存储元素,head.item = null
takeLock和notEmpty:出队的锁以及出队条件
putLock和notFull:入队的锁以及入队条件
可以看出与ArrayBlockingQueue不同的是,在LinkedBlockingQueue中,入队和出队分别使用两个锁,两个锁可以分别认为是毒写锁和读锁,这里的具体原因在后面会进行详细描述

基本使用

        //定义LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();// 入队方法queue.add(1);queue.offer(2);queue.offer(3,10, TimeUnit.SECONDS);queue.put(4);System.out.println(queue.size());// 出队方法Integer x1 = queue.remove();Integer x2 = queue.poll();Integer x3 = queue.poll(10, TimeUnit.SECONDS);Integer x4 = queue.take();System.out.println(x1);System.out.println(x2);System.out.println(x3);System.out.println(x4);//队列已用数目System.out.println(queue.size());//剩余可用数目System.out.println(queue.remainingCapacity());

入队和出队方法

入队

put

首先我们来看下阻塞入队方法put(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);// 元素数量增1,返回操作前的数量c = count.getAndIncrement();// c+1为当前队列的元素,如果小于容量,则唤醒notFull的等待线程,触发继续入队操作if (c + 1 < capacity)notFull.signal();} finally {// 释放锁putLock.unlock();}// c为入队前的元素数量,也就是入队前队列为空,则需要唤醒非空条件notEmpty的等待线程,触发出队操作if (c == 0)signalNotEmpty();
}private void signalNotEmpty() {final ReentrantLock takeLock = this.takeLock;takeLock.lock();try {// 唤醒出队等待的线程notEmpty.signal();} finally {takeLock.unlock();}
}

通过上面的代码,我们可以看出put(e)方法的主要流程如下:

首先生成待插入节点Node node = new Node(e)
然后尝试使用putLock上锁:如果当前无其他线程进行入队操作,则上锁成功;如果当前有其他线程进行入队操作,则进行等待,直到加锁成功;
加锁成功之后,首先进行队列容量的检查:如果元素数量等于队列容量,则无空间插入新元素,那么调用notFull.await()阻塞当前线程(当前线程被加入notFull条件的等待队列中;如果当前线程被唤醒,也需要再次检查是否有空间插入,如果没有还需要继续等待;
当队列有空间时,则调用enqueue(node)进行入队操作,将新节点node插入到链表中
入队完成后,对元素数量进行+1操作,并获取入队前的元素数量
判断当前元素数量小于队列容量时,则调用notFull.signal()唤醒一个等待入队的线程
释放锁
最后检查入队前元素数量为0,也就是队列为空时,那么此时队列不为空,则需要唤醒等待出队条件notEmpty的线程,触发出队操作,调用方法signalNotEmpty。
到这里我们已经看完了整个put(e)操作的主流程,然后我们再看下enqueue(node)操作的具体逻辑,代码如下:

private void enqueue(Node<E> node) {// assert putLock.isHeldByCurrentThread();// assert last.next == null;last = last.next = node;
}
入队操作offer

在LinkedBlockingQueue中提供了两个offer重载方法,一个是offer(E e),另外一个是offer(E e, long timeout, TimeUnit unit),两者的区别如下:
offer(E e)方法在入队时,如果当前队列有空间则直接入队,没有空间则入队失败,返回false;
offer(E e, long timeout, TimeUnit unit)是带等待时间的阻塞入队方法,有空间直接入队,没有空间则等待特定的时间,如果依然无法入队,则返回false

入队操作add

在LinkedBlockingQueue中,由于继承了AbstractQueue类,所以add方法也是使用的AbstractQueue中的定义,代码如下;add方法直接调用了offer(E e)方法,并判断是否入队成功,如果入队失败则抛出异常

出队

出队操作take

我们还是先看阻塞出队方法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();// 队列元素数量-1,返回c = count.getAndDecrement();// 出队前队列元素大于1,也就是当前队列还有元素,则唤醒一个等待出队的线程if (c > 1)notEmpty.signal();} finally {// 释放锁takeLock.unlock();}// 出队前队列元素等于队列容量,也就是出队后队列不满,则唤醒等待入队的线程if (c == capacity)signalNotFull();return x;
}private void signalNotFull() {final ReentrantLock putLock = this.putLock;putLock.lock();try {// 唤醒等待入队的线程notFull.signal();} finally {putLock.unlock();}
}

通过上面的代码,我们可以看出take()方法的主要流程如下:

尝试使用takeLock上锁:如果当前无其他线程进行出队操作,则上锁成功;如果当前有其他线程进行出队操作,则进行等待,直到加锁成功;
加锁成功之后,首先进行队列容量的检查:如果队列为空,则调用notEmpty.await()阻塞当前线程;如果当前线程被唤醒,也需要再次检查队列是否为空,如果为空则继续等待;
当队列不为空,则调用dequeue()进行出队操作,返回出队元素x;
出队完成后,对元素数量进行-1操作,并获取出队前的元素数量
判断当前队列中是否还有元素,如果有则调用notEmpty.signal()唤醒一个等待出队的线程
释放锁
最后检查出队前队列是否满的,如果是满的,则出队后队列不满,则需要唤醒等待入队条件notFull的线程,触发入队操作,调用方法signalNotFull
在进行出队操作时,调用dequeue()方法,下面看下该方法的具体实现,代码如下:

private E dequeue() {// assert takeLock.isHeldByCurrentThread();// assert head.item == null;// 当前头结点(头结点不存储数据,第一个元素为head.next)Node<E> h = head;// 当前队列中第一个元素Node<E> first = h.next;// 原头结点设置无效h.next = h; // help GC// 最新的头结点指向第一个元素firsthead = first;// 获得第一个元素的值E x = first.item;// 将第一个元素值设置为null,第一个元素变成头结点first.item = null;// 返回第一个元素值return x;
}
出队操作poll

同样的,LinkedBlockingQueue也提供了两个出队poll方法,一个是poll(),有元素则直接出队,无元素则返回null;另一个是poll(long time, TimeUnit unit),带等待时间的出队方法,当有元素时直接出队,无元素时则等待特定时间。

出队操作remove

在LinkedBlockingQueue中,remove方法也是直接使用的父类AbstractQueue中的remove方法;方法直接调用了poll()方法,如果出队成功则返回出队元素,出队失败则抛出NoSuchElementException异常。

使用实例

生产者:

// 生产者线程
Thread producer = new Thread(() -> {try {queue.put("Item 1");queue.put("Item 2");// 队列已满,put操作将被阻塞} catch (InterruptedException e) {e.printStackTrace();}
});
producer.start();

消费者:

// 消费者线程
Thread consumer = new Thread(() -> {try {String item = queue.take();System.out.println("Consumed: " + item);Thread.sleep(1000);item = queue.take();System.out.println("Consumed: " + item);} catch (InterruptedException e) {e.printStackTrace();}
});
consumer.start();

对比ArrayBlockingQueue

ArrayBlockingQueue中,使用了一个ReentrantLock lock作为入队和出队的锁,并使用两个条件notEmpty和notFull来进行线程间通信。而在本文介绍的LinkedBlockingQueue中,使用了两个锁putLock和takeLock分别作为入队和出队的锁,同样使用了两个锁的两个条件notFull和notEmpty进行线程间通信。
由于在ArrayBlockingQueue中,入队和出队操作共用了同一个锁,所以两个操作之间会有相互影响;而在LinkedBlockingQueue中,入队和出队操作分别使用不同的锁,则入队和出队互不影响,可以提供队列的操作性

参考来源:https://juejin.cn/post/7000515796053000228

这篇关于Java堵塞队列--LinkedBlockingQueue的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/319916

相关文章

Java编译生成多个.class文件的原理和作用

《Java编译生成多个.class文件的原理和作用》作为一名经验丰富的开发者,在Java项目中执行编译后,可能会发现一个.java源文件有时会产生多个.class文件,从技术实现层面详细剖析这一现象... 目录一、内部类机制与.class文件生成成员内部类(常规内部类)局部内部类(方法内部类)匿名内部类二、

SpringBoot实现数据库读写分离的3种方法小结

《SpringBoot实现数据库读写分离的3种方法小结》为了提高系统的读写性能和可用性,读写分离是一种经典的数据库架构模式,在SpringBoot应用中,有多种方式可以实现数据库读写分离,本文将介绍三... 目录一、数据库读写分离概述二、方案一:基于AbstractRoutingDataSource实现动态

Springboot @Autowired和@Resource的区别解析

《Springboot@Autowired和@Resource的区别解析》@Resource是JDK提供的注解,只是Spring在实现上提供了这个注解的功能支持,本文给大家介绍Springboot@... 目录【一】定义【1】@Autowired【2】@Resource【二】区别【1】包含的属性不同【2】@

springboot循环依赖问题案例代码及解决办法

《springboot循环依赖问题案例代码及解决办法》在SpringBoot中,如果两个或多个Bean之间存在循环依赖(即BeanA依赖BeanB,而BeanB又依赖BeanA),会导致Spring的... 目录1. 什么是循环依赖?2. 循环依赖的场景案例3. 解决循环依赖的常见方法方法 1:使用 @La

Java枚举类实现Key-Value映射的多种实现方式

《Java枚举类实现Key-Value映射的多种实现方式》在Java开发中,枚举(Enum)是一种特殊的类,本文将详细介绍Java枚举类实现key-value映射的多种方式,有需要的小伙伴可以根据需要... 目录前言一、基础实现方式1.1 为枚举添加属性和构造方法二、http://www.cppcns.co

Elasticsearch 在 Java 中的使用教程

《Elasticsearch在Java中的使用教程》Elasticsearch是一个分布式搜索和分析引擎,基于ApacheLucene构建,能够实现实时数据的存储、搜索、和分析,它广泛应用于全文... 目录1. Elasticsearch 简介2. 环境准备2.1 安装 Elasticsearch2.2 J

Java中的String.valueOf()和toString()方法区别小结

《Java中的String.valueOf()和toString()方法区别小结》字符串操作是开发者日常编程任务中不可或缺的一部分,转换为字符串是一种常见需求,其中最常见的就是String.value... 目录String.valueOf()方法方法定义方法实现使用示例使用场景toString()方法方法

Java中List的contains()方法的使用小结

《Java中List的contains()方法的使用小结》List的contains()方法用于检查列表中是否包含指定的元素,借助equals()方法进行判断,下面就来介绍Java中List的c... 目录详细展开1. 方法签名2. 工作原理3. 使用示例4. 注意事项总结结论:List 的 contain

Java实现文件图片的预览和下载功能

《Java实现文件图片的预览和下载功能》这篇文章主要为大家详细介绍了如何使用Java实现文件图片的预览和下载功能,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... Java实现文件(图片)的预览和下载 @ApiOperation("访问文件") @GetMapping("

Spring Boot + MyBatis Plus 高效开发实战从入门到进阶优化(推荐)

《SpringBoot+MyBatisPlus高效开发实战从入门到进阶优化(推荐)》本文将详细介绍SpringBoot+MyBatisPlus的完整开发流程,并深入剖析分页查询、批量操作、动... 目录Spring Boot + MyBATis Plus 高效开发实战:从入门到进阶优化1. MyBatis