这两个队列都是线程安全的。

LinkedBlockingQueue:

public class LinkedBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, Serializable  

此队列按 FIFO(先进先出)排序元素。队列的头部 是在队列中时间最长的元素。队列的尾部 是在队列中时间最短的元素。新元素插入到队列的尾部,并且队列检索操作会获得位于队列头部的元素。

链接队列的吞吐量通常要高于基于数组的队列,但是在大多数并发应用程序中,其可预知的性能要低。可选的容量范围构造方法参数作为防止队列过度扩展的一种方法。如果未指定容量,则它等于Integer.MAX_VALUE。除非插入节点会使队列超出容量,否则每次插入后会动态地创建链接节点。

适用阻塞队列的好处:多线程操作共同的队列时不需要额外的同步,另外就是队列会自动平衡负载,即那边(生产与消费两边)处理快了就会被阻塞掉,从而减少两边的处理速度差距。

Demo:

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue; public class Main {
public static void main(String[] args) {
// 建立一个装苹果的篮子
Basket basket = new Basket();
ExecutorService service = Executors.newCachedThreadPool();
Producer producer = new Producer("生产者001", basket);
Producer producer2 = new Producer("生产者002", basket);
Consumer consumer = new Consumer("消费者001", basket);
service.submit(producer);
service.submit(producer2);
service.submit(consumer);
// 程序运行5s后,所有任务停止
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
service.shutdownNow(); }
} /**
*
* 定义装苹果的篮子
*
*/
class Basket {
// 篮子,能够容纳3个苹果
BlockingQueue<String> basket = new LinkedBlockingQueue<String>(3);
int i=0;
// 生产苹果,放入篮子
public void produce() throws InterruptedException {
// put方法放入一个苹果,若basket满了,等到basket有位置
i++;
basket.put("An apple"+i);
} // 消费苹果,从篮子中取走
public String consume() throws InterruptedException {
// take方法取出一个苹果,若basket为空,等到basket有苹果为止(获取并移除此队列的头部)
return basket.take();
}
} // 定义苹果生产者
class Producer implements Runnable {
private String instance;
private Basket basket; public Producer(String instance, Basket basket) {
this.instance = instance;
this.basket = basket;
} public void run() {
try {
while (true) {
// 生产苹果
System.out.println("生产者准备生产苹果:" + instance);
basket.produce();
System.out.println("!生产者生产苹果完毕:" + instance);
// 休眠300ms
Thread.sleep(300);
}
} catch (InterruptedException ex) {
System.out.println("Producer Interrupted");
}
}
} // 定义苹果消费者
class Consumer implements Runnable {
private String instance;
private Basket basket; public Consumer(String instance, Basket basket) {
this.instance = instance;
this.basket = basket;
} public void run() {
try {
while (true) {
// 消费苹果
System.out.println("消费者准备消费苹果:" + instance);
System.out.println(basket.consume());
System.out.println("!消费者消费苹果完毕:" + instance);
// 休眠1000ms
Thread.sleep(1000);
}
} catch (InterruptedException ex) {
System.out.println("Consumer Interrupted");
}
}
}
生产者准备生产苹果:生产者001
消费者准备消费苹果:消费者001
生产者准备生产苹果:生产者002
!生产者生产苹果完毕:生产者002
!生产者生产苹果完毕:生产者001
An apple1
!消费者消费苹果完毕:消费者001
生产者准备生产苹果:生产者001
生产者准备生产苹果:生产者002
!生产者生产苹果完毕:生产者001
!生产者生产苹果完毕:生产者002
生产者准备生产苹果:生产者001
生产者准备生产苹果:生产者002
消费者准备消费苹果:消费者001
An apple2
!生产者生产苹果完毕:生产者001
!消费者消费苹果完毕:消费者001
生产者准备生产苹果:生产者001
消费者准备消费苹果:消费者001
An apple3
!消费者消费苹果完毕:消费者001
!生产者生产苹果完毕:生产者002
生产者准备生产苹果:生产者002
消费者准备消费苹果:消费者001
An apple4
!消费者消费苹果完毕:消费者001
!生产者生产苹果完毕:生产者001
生产者准备生产苹果:生产者001
消费者准备消费苹果:消费者001
An apple5
!消费者消费苹果完毕:消费者001
!生产者生产苹果完毕:生产者002
生产者准备生产苹果:生产者002
Producer Interrupted
Producer Interrupted
Consumer Interrupted

ConcurrentLinkedQueue:(http://blog.csdn.net/chenssy/article/details/74853120)

ConcurrentLinkedQueue是一个基于链接节点的无界线程安全队列,它采用先进先出的规则对节点进行排序,当我们添加一个元素的时候,它会添加到队列的尾部,当我们获取一个元素时,它会返回队列头部的元素。

使用并发队列,虽然能即时返回结果(消费结果),但必须自行编码解决返回为空的情况处理(以及消费重试等问题)。

代码:

package com.qhong;

import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; public class Main {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(2); executorService.submit(new NoBlockQueue.Producer("producer1"));
executorService.submit(new NoBlockQueue.Producer("producer2"));
executorService.submit(new NoBlockQueue.Producer("producer3"));
executorService.submit(new NoBlockQueue.Consumer("consumer1"));
executorService.submit(new NoBlockQueue.Consumer("consumer2"));
executorService.submit(new NoBlockQueue.Consumer("consumer3"));
}
}
class NoBlockQueue {
private static ConcurrentLinkedQueue<Integer> concurrentLinkedQueue = new ConcurrentLinkedQueue<Integer>();
static class Producer implements Runnable {
private String name; public Producer(String name) {
this.name = name;
} public void run() {
for (int i = 1; i < 10; ++i) {
System.out.println(Thread.currentThread().getName()+"-----"+ name+ " start producer " + i);
concurrentLinkedQueue.add(i);
try {
Thread.sleep(20);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
} static class Consumer implements Runnable {
private String name; public Consumer(String name) {
this.name = name;
}
public void run() {
for (int i = 1; i < 10; ++i) {
try {
System.out.println(Thread.currentThread().getName()+"-----"+name+" Consumer " + concurrentLinkedQueue.poll());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}

Output:

pool-1-thread-1-----producer1 start producer 1
pool-1-thread-2-----producer2 start producer 1
pool-1-thread-1-----producer1 start producer 2
pool-1-thread-2-----producer2 start producer 2
pool-1-thread-1-----producer1 start producer 3
pool-1-thread-2-----producer2 start producer 3
pool-1-thread-1-----producer1 start producer 4
pool-1-thread-2-----producer2 start producer 4
pool-1-thread-1-----producer1 start producer 5
pool-1-thread-2-----producer2 start producer 5
pool-1-thread-2-----producer2 start producer 6
pool-1-thread-2-----producer2 start producer 7
pool-1-thread-1-----producer1 start producer 6
pool-1-thread-2-----producer2 start producer 8
pool-1-thread-1-----producer1 start producer 7
pool-1-thread-2-----producer2 start producer 9
pool-1-thread-1-----producer1 start producer 8
pool-1-thread-1-----producer1 start producer 9
pool-1-thread-2-----producer3 start producer 1
pool-1-thread-1-----consumer1 Consumer 1
pool-1-thread-1-----consumer1 Consumer 1
pool-1-thread-1-----consumer1 Consumer 2
pool-1-thread-1-----consumer1 Consumer 2
pool-1-thread-1-----consumer1 Consumer 3
pool-1-thread-1-----consumer1 Consumer 3
pool-1-thread-1-----consumer1 Consumer 4
pool-1-thread-1-----consumer1 Consumer 4
pool-1-thread-1-----consumer1 Consumer 5
pool-1-thread-1-----consumer2 Consumer 5
pool-1-thread-1-----consumer2 Consumer 6
pool-1-thread-1-----consumer2 Consumer 7
pool-1-thread-1-----consumer2 Consumer 6
pool-1-thread-1-----consumer2 Consumer 8
pool-1-thread-1-----consumer2 Consumer 7
pool-1-thread-1-----consumer2 Consumer 9
pool-1-thread-1-----consumer2 Consumer 8
pool-1-thread-1-----consumer2 Consumer 9
pool-1-thread-1-----consumer3 Consumer 1
pool-1-thread-1-----consumer3 Consumer null
pool-1-thread-1-----consumer3 Consumer null
pool-1-thread-1-----consumer3 Consumer null
pool-1-thread-1-----consumer3 Consumer null
pool-1-thread-1-----consumer3 Consumer null
pool-1-thread-1-----consumer3 Consumer null
pool-1-thread-1-----consumer3 Consumer null
pool-1-thread-1-----consumer3 Consumer null
pool-1-thread-2-----producer3 start producer 2
pool-1-thread-2-----producer3 start producer 3
pool-1-thread-2-----producer3 start producer 4
pool-1-thread-2-----producer3 start producer 5
pool-1-thread-2-----producer3 start producer 6
pool-1-thread-2-----producer3 start producer 7
pool-1-thread-2-----producer3 start producer 8
pool-1-thread-2-----producer3 start producer 9

http://www.cnblogs.com/linjiqin/archive/2013/05/30/3108188.html

http://blog.csdn.net/ac903919/article/details/6967728

http://www.soso.io/article/66762.html

http://ifeve.com/concurrentlinkedqueue/

http://www.cnblogs.com/sunshine-2015/p/6067709.html

阻塞队列LinkedBlockingQueue和并发队列ConcurrentLinkedQueue的更多相关文章

  1. 并发队列ConcurrentLinkedQueue、阻塞队列AraayBlockingQueue、阻塞队列LinkedBlockingQueue 区别和使用场景总结

      三者区别与联系: 联系,三者 都是线程安全的.区别,就是 并发  和 阻塞,前者为并发队列,因为采用cas算法,所以能够高并发的处理:后2者采用锁机制,所以是阻塞的.注意点就是前者由于采用cas算 ...

  2. 自己总结 :并发队列ConcurrentLinkedQueue、阻塞队列AraayBlockingQueue、阻塞队列LinkedBlockingQueue 区别 和 使用场景总结

    并发队列ConcurrentLinkedQueue.阻塞队列AraayBlockingQueue.阻塞队列LinkedBlockingQueue 区别 和  使用场景总结 分类: Java2013-0 ...

  3. Java深入学习(2):并发队列

    并发队列: 在并发队列中,JDK有两套实现: ConcurrentLinkedQueue:非阻塞式队列 BlockingQueue:阻塞式队列 阻塞式队列非阻塞式队列的区别: 阻塞式队列入列操作的时候 ...

  4. [Java 基础] 并发队列ConcurrentLinkedQueue和阻塞队列LinkedBlockingQueue用法

    reference : http://www.cnblogs.com/linjiqin/archive/2013/05/30/3108188.html 在Java多线程应用中,队列的使用率很高,多数生 ...

  5. 并发队列ConcurrentLinkedQueue和阻塞队列LinkedBlockingQueue用法

    在Java多线程应用中,队列的使用率很高,多数生产消费模型的首选数据结构就是队列(先进先出).Java提供的线程安全的Queue可以分为阻塞队列和非阻塞队列,其中阻塞队列的典型例子是BlockingQ ...

  6. 并发队列ConcurrentLinkedQueue和阻塞队列LinkedBlockingQueue用法(转)

    在Java多线程应用中,队列的使用率很高,多数生产消费模型的首选数据结构就是队列(先进先出).Java提供的线程安全的Queue可以分为阻塞队列和非阻塞队列,其中阻塞队列的典型例子是BlockingQ ...

  7. 并发队列ConcurrentLinkedQueue 和 阻塞队列LinkedBlockingQueue用法

    在Java多线程应用中,队列的使用率很高,多数生产消费模型的首选数据结构就是队列(先进先出).Java提供的线程安全的Queue可以分为阻塞队列和非阻塞队列,其中阻塞队列的典型例子是BlockingQ ...

  8. 并发队列ConcurrentLinkedQueue与阻塞队列LinkedBlockingQueue的区别

    1.  介绍背景 在Java多线程应用中,队列的使用率很高,多数生产消费模型的首选数据结构就是队列. Java提供的线程安全的Queue可以分为阻塞队列和非阻塞队列,其中阻塞队列的典型例子是Block ...

  9. (原创)JAVA阻塞队列LinkedBlockingQueue 以及非阻塞队列ConcurrentLinkedQueue 的区别

    阻塞队列:线程安全 按 FIFO(先进先出)排序元素.队列的头部 是在队列中时间最长的元素.队列的尾部 是在队列中时间最短的元素.新元素插入到队列的尾部,并且队列检索操作会获得位于队列头部的元素.链接 ...

随机推荐

  1. ACM : Travel-并查集-最小生成树 + 离线-解题报告

    Travel Time Limit:1000MS     Memory Limit:131072KB     64bit IO Format:%I64d & %I64u /*题意 给出n[节点 ...

  2. BZOJ 1045 题解

    1045: [HAOI2008] 糖果传递 Time Limit: 10 Sec  Memory Limit: 162 MBSubmit: 3502  Solved: 1623[Submit][Sta ...

  3. HDU 4778 Gems Fight!(DP)

    题目链接 当我放弃的时候过了.sb啊,卡常数!!! 换了好几个姿势,本来没写预处理,预处理+俩剪枝,尼玛就过了.. #include <stdio.h> #include <stri ...

  4. UVA 10791 - Minimum Sum LCM(坑)

    题目链接 不知道为什么,我用cin,cout就是过不了...改成scanf过了... 还是我居然理解错题意了,已经不能用看错了...至少两个数字,我理解成两个数字了,还写了个爆搜... #includ ...

  5. Linux下设置svn过滤文件类型

    1)修改客户端. 1.修改客户端 1)编辑文件家目录下自己账户下的.subversion/config文件 vim ~/.subversion/config 2)找到包含[miscellany]的一行 ...

  6. 使用audio标签播放音频文件

    HTML5定义了一个新的元素用来指定标准的方式来插入音频文件到web页面中:<audio>标签.使用audio标签可以控制音频的播放与停止,循环播放与播放次数设置,以及播放位置等等. 例如 ...

  7. JQuery的动画及其幻灯片效果

    1.显示和隐藏hide()和show() 对于动画来说,显示和隐藏是最基本的效果之一,简单介绍jQuery的显示和隐藏. <script type="text/javascript&q ...

  8. [LintCode] Gray Code 格雷码

    The gray code is a binary numeral system where two successive values differ in only one bit. Given a ...

  9. [zt]OpenCV2.1.0的安装

    下载和安装 OpenCV 2.1.0 2.添加库文件:打开VS 2008,选择菜单:Tools->options->Projects and Solutions >VC++ Dire ...

  10. Linux_几个符号命令

    一.管道符号 | (将前面命令的输出结果传给后面的命令) [eRrsr@hadoop09-linux ~]$ cat /etc/passwd | grep "^root" root ...