LinkedBlockingQueue的put,add跟offer的区别

本文深入探讨了Java并发包中LinkedBlockingQueue的三种插入方法:add、put与offer的区别。通过对比它们在队列满时的行为差异,帮助读者理解何时使用何种方法更为合适。
LinkedBlockingQueue的put,add和offer的区别 

      最近在学习<<Java并发编程实践>>,有很多java.util.concurrent包下的新类。LinkedBlockingQueue就是其中之一,顾名思义这是一个阻塞的线程安全的队列,底层应该采用链表实现。

       看其API的时候发现,添加元素的方法竟然有三个:add,put,offer。

且这三个元素都是向队列尾部添加元素的意思。于是我产生了兴趣,要仔细探究一下他们之间的差别。

1.首先看一下add方法:

    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. 

    This implementation returns true if offer succeeds, else throws an IllegalStateException.

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

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

public static void main(String args[]){
		try {
			LinkedBlockingQueue<String> queue=new LinkedBlockingQueue(2);
			
			queue.add("hello");
			queue.add("world");
			queue.add("yes");
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
//运行结果:
java.lang.IllegalStateException: Queue full
	at java.util.AbstractQueue.add(Unknown Source)
	at com.wjy.test.GrandPather.main(GrandPather.java:12)

 

2.再来看一下put方法:

    Inserts the specified element at the tail of this queue, waiting if necessary for space to become available.

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

public static void main(String args[]){
		try {
			LinkedBlockingQueue<String> queue=new LinkedBlockingQueue(2);
			
			queue.put("hello");
			queue.put("world");
			queue.put("yes");
			
			System.out.println("yes");
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
//运行结果:
//在queue.put("yes")处发生阻塞
//下面的“yes”无法输出

 

3.最后看一下offer方法:

     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。

 

public static void main(String args[]){
		try {
			LinkedBlockingQueue<String> queue=new LinkedBlockingQueue(2);
			
			boolean bol1=queue.offer("hello");
			boolean bol2=queue.offer("world");
			boolean bol3=queue.offer("yes");
			
			System.out.println(queue.toString());
			System.out.println(bol1);
			System.out.println(bol2);
			System.out.println(bol3);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
//运行结果:
[hello, world]
true
true
false

 

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

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

 

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

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

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

虽然给定引用中未提及 LinkedBlockingQueue 相关内容,但可以基于常见的专业知识来介绍其常见问题及解决办法。 ### 队列满导致添加元素失败 当 LinkedBlockingQueue 达到其容量上限时,调用 `put()` 方法会阻塞,调用 `add()` 方法会抛出 `IllegalStateException`,调用 `offer()` 方法会返回 `false`。 解决办法: - 使用 `put()` 方法时,它会阻塞线程直到有空间可用。示例代码如下: ```java import java.util.concurrent.LinkedBlockingQueue; public class LinkedBlockingQueueExample { public static void main(String[] args) throws InterruptedException { LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(1); queue.put(1); // 下面这行代码会阻塞,直到队列有空间 queue.put(2); } } ``` - 使用 `offer(E e, long timeout, TimeUnit unit)` 方法,设置一个超时时间,若在超时时间内仍无空间则返回 `false`。示例代码如下: ```java import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.TimeUnit; public class LinkedBlockingQueueOfferExample { public static void main(String[] args) throws InterruptedException { LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(1); queue.offer(1); boolean result = queue.offer(2, 1, TimeUnit.SECONDS); System.out.println(result); } } ``` ### 队列空导致获取元素失败 当 LinkedBlockingQueue 为空时,调用 `take()` 方法会阻塞,调用 `remove()` 方法会抛出 `NoSuchElementException`,调用 `poll()` 方法会返回 `null`。 解决办法: - 使用 `take()` 方法时,它会阻塞线程直到有元素可用。示例代码如下: ```java import java.util.concurrent.LinkedBlockingQueue; public class LinkedBlockingQueueTakeExample { public static void main(String[] args) throws InterruptedException { LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(); // 下面这行代码会阻塞,直到队列有元素 Integer element = queue.take(); } } ``` - 使用 `poll(long timeout, TimeUnit unit)` 方法,设置一个超时时间,若在超时时间内仍无元素则返回 `null`。示例代码如下: ```java import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.TimeUnit; public class LinkedBlockingQueuePollExample { public static void main(String[] args) throws InterruptedException { LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(); Integer element = queue.poll(1, TimeUnit.SECONDS); System.out.println(element); } } ``` ### 并发修改问题 在多线程环境下,多个线程同时对 LinkedBlockingQueue 进行修改操作可能会导致数据不一致等问题。 解决办法: 由于 LinkedBlockingQueue 是线程安全的,它内部使用了锁机制来保证线程安全,一般情况下可以直接使用。但如果需要更复杂的并发控制,可以结合 `ReentrantLock` 等锁来实现。示例代码如下: ```java import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.locks.ReentrantLock; public class LinkedBlockingQueueConcurrentExample { private static LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(); private static ReentrantLock lock = new ReentrantLock(); public static void main(String[] args) { new Thread(() -> { lock.lock(); try { queue.offer(1); } finally { lock.unlock(); } }).start(); new Thread(() -> { lock.lock(); try { Integer element = queue.poll(); System.out.println(element); } finally { lock.unlock(); } }).start(); } } ```
评论 4
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值