LinkedBlockingQueue的put,add跟offer的区别

最新推荐文章于 2024-06-17 09:13:08 发布
转载 最新推荐文章于 2024-06-17 09:13:08 发布 · 455 阅读 · 0
文章标签：

#LinkedBlockingQueue

本文详细解析了Java并发包中LinkedBlockingQueue的add、put、offer三种添加元素方法的区别，并介绍了poll、remove、take三种从队列中取出元素的方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

LinkedBlockingQueue顾名思义这是一个阻塞的线程安全的队列，底层应该采用链表实现。 看其API的时候发现，添加元素的方法竟然有三个：add,put,offer。 且这三个方法都是向队列尾部添加元素的意思。于是我产生了兴趣，要仔细探究一下他们之间的差别。

1.首先看一下add方法：

[java]  view plain  copy
  1. Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.   
  2.   
  3. This implementation returns true if offer succeeds, else throws an IllegalStateException.  
[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.   
  2.   
  3. This implementation returns true if offer succeeds, else throws an IllegalStateException.  

        LinkedBlockingQueue构造的时候若没有指定大小，则默认大小为Integer.MAX_VALUE，当然也可以在构造函数的参数中指定大小。LinkedBlockingQueue不接受null。

       add方法在添加元素的时候，若超出了度列的长度会直接抛出异常：

[java]  view plain  copy
  1. public static void main(String args[]){  
  2.         try {  
  3.             LinkedBlockingQueue<String> queue=new LinkedBlockingQueue(2);  
  4.               
  5.             queue.add("hello");  
  6.             queue.add("world");  
  7.             queue.add("yes");  
  8.         } catch (Exception e) {  
  9.             // TODO: handle exception  
  10.             e.printStackTrace();  
  11.         }  
  12.     }  
  13. //运行结果：  
  14. java.lang.IllegalStateException: Queue full  
  15.     at java.util.AbstractQueue.add(Unknown Source)  
  16.     at com.wjy.test.GrandPather.main(GrandPather.java:12)  
[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public static void main(String args[]){  
  2.         try {  
  3.             LinkedBlockingQueue<String> queue=new LinkedBlockingQueue(2);  
  4.               
  5.             queue.add("hello");  
  6.             queue.add("world");  
  7.             queue.add("yes");  
  8.         } catch (Exception e) {  
  9.             // TODO: handle exception  
  10.             e.printStackTrace();  
  11.         }  
  12.     }  
  13. //运行结果：  
  14. java.lang.IllegalStateException: Queue full  
  15.     at java.util.AbstractQueue.add(Unknown Source)  
  16.     at com.wjy.test.GrandPather.main(GrandPather.java:12)  

 

2.再来看一下put方法：

[java]  view plain  copy
  1. Inserts the specified element at the tail of this queue, waiting if necessary for space to become available.  
[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. Inserts the specified element at the tail of this queue, waiting if necessary for space to become available.  

      对于put方法，若向队尾添加元素的时候发现队列已经满了会发生阻塞一直等待空间，以加入元素。

[java]  view plain  copy
  1. public static void main(String args[]){  
  2.         try {  
  3.             LinkedBlockingQueue<String> queue=new LinkedBlockingQueue(2);  
  4.               
  5.             queue.put("hello");  
  6.             queue.put("world");  
  7.             queue.put("yes");  
  8.               
  9.             System.out.println("yes");  
  10.         } catch (Exception e) {  
  11.             // TODO: handle exception  
  12.             e.printStackTrace();  
  13.         }  
  14.     }  
  15. //运行结果：  
  16. //在queue.put("yes")处发生阻塞  
  17. //下面的“yes”无法输出  
[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public static void main(String args[]){  
  2.         try {  
  3.             LinkedBlockingQueue<String> queue=new LinkedBlockingQueue(2);  
  4.               
  5.             queue.put("hello");  
  6.             queue.put("world");  
  7.             queue.put("yes");  
  8.               
  9.             System.out.println("yes");  
  10.         } catch (Exception e) {  
  11.             // TODO: handle exception  
  12.             e.printStackTrace();  
  13.         }  
  14.     }  
  15. //运行结果：  
  16. //在queue.put("yes")处发生阻塞  
  17. //下面的“yes”无法输出  

 

3.最后看一下offer方法：

[java]  view plain  copy
  1. Inserts the specified element at the tail of this queue if it is possible to do so immediately without exceeding the queue's capacity, returning true upon success and false if this queue is full. When using a capacity-restricted queue, this method is generally preferable to method add, which can fail to insert an element only by throwing an exception.  
[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. Inserts the specified element at the tail of this queue if it is possible to do so immediately without exceeding the queue's capacity, returning true upon success and false if this queue is full. When using a capacity-restricted queue, this method is generally preferable to method add, which can fail to insert an element only by throwing an exception.  

   

    offer方法在添加元素时，如果发现队列已满无法添加的话，会直接返回false。

 

[java]  view plain  copy
  1. public static void main(String args[]){  
  2.         try {  
  3.             LinkedBlockingQueue<String> queue=new LinkedBlockingQueue(2);  
  4.               
  5.             boolean bol1=queue.offer("hello");  
  6.             boolean bol2=queue.offer("world");  
  7.             boolean bol3=queue.offer("yes");  
  8.               
  9.             System.out.println(queue.toString());  
  10.             System.out.println(bol1);  
  11.             System.out.println(bol2);  
  12.             System.out.println(bol3);  
  13.         } catch (Exception e) {  
  14.             // TODO: handle exception  
  15.             e.printStackTrace();  
  16.         }  
  17.     }  
  18. //运行结果：  
  19. [hello, world]  
  20. true  
  21. true  
  22. false  
[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public static void main(String args[]){  
  2.         try {  
  3.             LinkedBlockingQueue<String> queue=new LinkedBlockingQueue(2);  
  4.               
  5.             boolean bol1=queue.offer("hello");  
  6.             boolean bol2=queue.offer("world");  
  7.             boolean bol3=queue.offer("yes");  
  8.               
  9.             System.out.println(queue.toString());  
  10.             System.out.println(bol1);  
  11.             System.out.println(bol2);  
  12.             System.out.println(bol3);  
  13.         } catch (Exception e) {  
  14.             // TODO: handle exception  
  15.             e.printStackTrace();  
  16.         }  
  17.     }  
  18. //运行结果：  
  19. [hello, world]  
  20. true  
  21. true  
  22. false  

 

    好了，竟然说了这么多了，就把从队列中取元素的方法也顺便一说。

从队列中取出并移除头元素的方法有：poll，remove，take。

 

poll: 若队列为空，返回null。

remove:若队列为空，抛出NoSuchElementException异常。

take:若队列为空，发生阻塞，等待有元素。


转载地址：http://blog.youkuaiyun.com/zmx729618/article/details/52979616 

BlockingQueue（阻塞队列）详解
javajy的博客
10-09 1237
在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。一旦获得了锁之后，如果队列为空，那么将阻塞；否则调用dequeue()出队一个元素。
java queue put offer_Java高并发系列之LinkedBlockingQueue源码解析
weixin_28957321的博客
03-04 254
首先，我们来看一下LinkedBlockingQueue的类图。在LinkedBlockingQueue的内部定义了两把锁，分别是takeLock和putLock，其都是ReentrantLock。其插入和取出元素分别在链表两端进行。从类图中可以看出，LinkedBlockingQueue继承了AbstractQueue类，同时实现了BlockingQueue接口。这个和ArrayBlocking...
多线程——LinkedBlockingQueue的put、add跟offer的区别
Mauanx的博客
11-06 2568
1. LinkedBlockingQueue的添加：add和offer的区别 eg: BlockingQueue<A> queue = new LinkedBlockingQueue<A>(CAPACITY); LinkedBlockingQueue是java.util.concurrent包下的新类。顾名思义是一个阻塞的线程安全的队列，底层应该采用链表...
Java 阻塞队列 BlockingQueue 介绍: put,add 和 offer 三个方法
牛肉胡辣汤
11-02 2623
在多线程编程中，经常需要使用线程安全的数据结构，用于在不同线程之间进行数据交换和通信。Java提供了一种称为阻塞队列（BlockingQueue）的数据结构，它是线程安全的队列实现，提供了一些特殊的方法来处理多线程环境下的数据交换问题。本文将介绍阻塞队列的基本概念和在Java中使用的三种常见方法：put，add和offer。阻塞队列是多线程编程中非常实用的数据结构，通过使用 put，add 和 offer 这三个方法，我们可以在多线程环境下实现线程之间的协调和同步。
线程基础—并发容器：LinkedBlockingQueue
wolfcode_cn的博客
02-15 1302
本文作者：王一飞，叩丁狼高级讲师。原创文章，转载请注明出处。 #####概念 LinkedBlockingQueue按照api解释：一个基于链表而实现的有界阻塞队列。遵循先进先出原则，由队头入列，再从队尾出列。具体操作上跟ArrayBlockingQueue类似，区别在于底层维护数据上，LinkedBlockingQueue底层是一个链接，而ArrayBlockingQueue是一个数组。 ...
了解Java的LinkedBlockingQueue
常备不懈
06-17 1283
`LinkedBlockingQueue`是一个基于链接节点的有界阻塞队列。它实现了`BlockingQueue`接口，可以在多线程环境中安全地进行插入、移除和检查操作。`LinkedBlockingQueue`的容量可以在创建时指定，如果未指定，则默认容量为Integer的最大值。
BlockingQueue之LinkedBlockingQueue
爪哇岛咖啡种植农场
06-24 663
BlockingQueue的实现类LinkedBlockingQueue
LinkedList、ConcurrentLinkedQueue、LinkedBlockingQueue对比分析
变个魔术
05-27 359
demo Lesson2ConcurrentLinkedQueuePerform:在使用ConcurrentLinkedQueue的情况下100个线程循环增加的元素数为：33828193。demo Lesson2LinkedBlockingQueuePerform:在使用LinkedBlockingQueue的情况下100个线程循环增加的元素数为：33827382。
第10篇 rabbitmq LinkedBlockingQueue(上篇）
往前的娘娘
06-09 601
这节主要分析和学习LinkedBlockingQueue队列特性，具体类图如下，我们理解它如何实现阻塞， 主要研究LinkedBlockingQueue的父类依赖抽象类和接口解析 1、分析上图 队列是集合的一种 BlockingQueue接口却不继承AbstractQueue 也说明它不同于一般的队列，也就在普通队列增加新特性一样（类似马添加翅膀的属性，它就具有飞功能） 它还实现Serializable接口说明具有在中网络传递该对象功能，支持序列化和反序列化 Iterable接口 需要实现 迭代器功.
你真的了解LinkedBlockingQueue的put,add和offer的区别吗
lucasma的博客
02-08 1373
概述 LinkedBlockingQueue的put,add和offer这三个方法功能很相似，都是往队列尾部添加一个元素。既然都是同样的功能，为啥要有有三个方法呢？ 这三个方法的区别在于： put方法添加元素，如果队列已满，会阻塞直到有空间可以放 add方法在添加元素的时候，若超出了度列的长度会直接抛出异常 offer方法添加元素，如果队列已满，直接返回false 索引这三种不同的方法在队列满...
阻塞队列-LinkedBlockingQueue
wssc63262的博客
01-19 5545
LinkedBlockingQueue是一个基于链表实现的阻塞队列，默认情况下，该阻塞队列的大小为Integer.MAX_VALUE，由于这个数值特别大，所以 LinkedBlockingQueue 也被称作无界队列
多线程基础（六、三）BlockingQueue用法详解之LinkedBlockingQueue
m0_47743175的博客
06-11 3511
BlockingQueue用法详解之LinkedBlockingQueue
java queue put take_阻塞队列的take、offer、put、add的一些比较
weixin_35662171的博客
02-13 1795
最近在学习<>，有很多java.util.concurrent包下的新类。LinkedBlockingQueue就是其中之一，顾名思义这是一个阻塞的线程安全的队列，底层应该采用链表实现。看其API的时候发现，添加元素的方法竟然有三个：add,put,offer。且这三个元素都是向队列尾部添加元素的意思。于是我产生了兴趣，要仔细探究一下他们之间的差别。1.首先看一下add方法：Inser...
LinkedBlockingQueue#put操作
书唐瑞的博客
09-05 778
JDK提供了7大阻塞队列,常用于实现生产者和消费者,LinkedBlockingQueue是最常用之一. 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 = th
LinkedBlockingQueue的put，take方法
Thxxxxxx
06-27 1832
put操作：在LinkedBlockingQueue中有putlcok和takelock俩把锁，put操作使用putlock这把锁，利用lockInterruptibly方法加锁，该方法的作用为：如果该线程被标记为中断，可抛出异常。加锁之后，判断count是否等于容量，相等的话条用await()方法线线程加到条件队列中去，直到唤醒，把元素加入到队列，然后判断一下count+1如果还没有达到容量值...
LinkedBlockingQueue put方法和take方法
Andy_Health的博客
11-24 1382
/** * 链表 */ static class Node<E> { E item; /** * 为null时，表示当前节点是队尾 */ Node<E> next; Node(E x) { item = x; } } /** 未指定的话，容量为Integer最大值 */ private final int capaci...
LinkedBlockingQueue使用总结
羽吉公
06-04 4463
复制粘贴整理, 参考地址 : https://blog.youkuaiyun.com/tonywu1992/article/details/83419448 https://www.cnblogs.com/duodushuduokanbao/p/9556555.html 2.3、方法 同样，LinkedBlockingQueue也有着和ArrayBlockingQueue一样的方法，我们先来看看入队列的方法。 2.3.1、入队方法 LinkedBlockingQueue提供了多种入队操作的实现来满足不同..
并发容器--LinkedBlockingQueue
libufan的博客
04-30 783
1、LinkedBlockingQueue数据结构 LinkedBlockingQueue是一种基于单向链表的阻塞队列。其数据结构如下，包含了头结点和尾节点。 2、LinkedBlockingQueue源码分析 类的继承关系 public class LinkedBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializ...
LinkedBlockingDeque和LinkedBlockingQueue的区别是什么
最新发布
04-09
### LinkedBlockingDeque 和 LinkedBlockingQueue 的主要区别 #### 数据结构设计 `LinkedBlockingQueue` 是一种基于链表的阻塞队列，允许在构造时指定其容量上限。如果不指定，默认容量为 `Integer.MAX_VALUE`。它的内部实现是一个单向链表[^2]。 相比之下，`LinkedBlockingDeque` 则是一种双端阻塞队列（deque），支持从两端进行插入和移除操作。这意味着它可以作为栈或者队列来使用，提供了更多的灵活性。其底层同样采用双向链表实现[^1]。 #### 功能特性对比 - **单一方向 vs 双向操作** - `LinkedBlockingQueue` 主要提供标准的一端入队另一端出队的功能。 - 而 `LinkedBlockingDeque` 不仅能像普通队列一样在一端添加元素并从另一端取出，还可以从前端或后端任意一端执行 push/pop 或 add/remove 操作[^4]。 - **线程安全性机制** 两者都具备良好的线程安全性能，并通过锁控制访问冲突情况下的资源竞争问题。不过由于 `LinkedBlockingDeque` 提供更多种可能的操作模式，所以在某些特殊情况下可能会稍微复杂一点处理逻辑上的互斥关系[^3]。 #### 使用场景分析 当只需要简单的先进先出(FIFO)行为时可以选择 `LinkedBlockingQueue`；但如果应用程序需要更加灵活的数据存取方式比如既要做到FIFO又要偶尔做LIFO(last-in-first-out),那么就应该考虑选用 `LinkedBlockingDeque`. 以下是两个类的部分核心方法列表比较： | 方法名 | 描述 | 存在于哪个类？ | |----------------|----------------------------------------------------------------------------------------|-------------------------| | offer(e) | 将指定元素加入队列尾部 | Both | | poll() | 获取并移除头部元素 | Both | | peek() | 查看但不移除头部元素 | Both | | put(e) | 如果必要则等待空间可用后再放入 | Both | | take() | 如果必要则等待直到有元素可获取 | Both | | addFirst(e) | 添加至开头 | Only LBD | | removeLast() | 删除最后一个 | Only LBD | ```java // Example of using LinkedBlockingDeque as a stack. import java.util.concurrent.LinkedBlockingDeque; public class StackExample { public static void main(String[] args)throws Exception{ LinkedBlockingDeque<Integer> stack=new LinkedBlockingDeque<>(); // Push elements onto the 'stack' stack.push(1); stack.push(2); System.out.println(stack.pop()); // Outputs: 2 System.out.println(stack.pop()); // Outputs: 1 } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值