并发队列 | 易学教程

一、介绍
在并发队列上JDK提供了两套实现，一个是以ConcurrentLinkedQueue为代表的高性能队
列，一个是以BlockingQueue接口为代表的阻塞队列，无论哪种都继承自Queue。

二、ConcurrentLinkedQueue
1. 介绍
ConcurrentLinkedQueue: 是一个适用于高并发场景下的队列，通过无锁的方式，实现
了高并发状态下的高性能，通常ConcurrentLinkedQueue性能好于BlockingQueue.它
是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最先
加入的，尾是最近加入的，该队列不允许null元素。

2. 重要方法:
add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中这俩个方法没有任何区别)
poll() 和peek() 都是取头元素节点，区别在于前者会删除元素，后者不会。

3. Java代码：

@Test
public void testConcurrentLinkedDeque() {
ConcurrentLinkedQueue<String> concurrentLinkedQueue = new ConcurrentLinkedQueue<String>();
concurrentLinkedQueue.offer("大都督");
try {
concurrentLinkedQueue.add(null);
} catch (Exception e) {
System.out.println("concurrentLinkedQueue不允许加入null值");
}
concurrentLinkedQueue.offer("小乔");
System.out.println("size:" + concurrentLinkedQueue.size());
System.out.println("peek:" + concurrentLinkedQueue.peek());
System.out.println("size:" + concurrentLinkedQueue.size());
System.out.println("poll:" + concurrentLinkedQueue.poll());
System.out.println("size:" + concurrentLinkedQueue.size());
}

4. 运行结果：

三、BlockingQueue
1. 介绍
BlockingQueue即阻塞队列，从阻塞这个词可以看出，在某些情况下对阻塞队列的访问可能会造成阻塞。被阻塞的情况主要有如下两种：
a. 当队列满了的时候进行入队列操作
b. 当队列空了的时候进行出队列操作
因此，当一个线程试图对一个已经满了的队列进行入队列操作时，它将会被阻塞，除非有另一个线程做了出队列操作；同样，当一个线程试图对一个空队列进行出队列操作时，它将会被阻塞，除非有另一个线程进行了入队列操作。

阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。

在Java中，BlockingQueue的接口位于java.util.concurrent 包中(在Java5版本开始提供)，由上面介绍的阻塞队列的特性可知，阻塞队列是线程安全的。

2. 生产者消费者运行结果：

。

3. Java代码

package com.example.demo.thread;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
* @Description 模拟生产者、消费者 
* @author 大都督
* @date 2019年5月1日
*/
public class BlockingQueueTest {

private static AtomicInteger count = new AtomicInteger();

//内部类：生产者
public class Producer implements Runnable{
private BlockingQueue blockingQueue;
private boolean flag = true;
public Producer(BlockingQueue blockingQueue) {//构造函数
this.blockingQueue = blockingQueue;
}
@Override
public void run() {
try {
System.out.println("生产线程启动");
while (flag) {
System.out.println("生产中...");
String data = count.incrementAndGet()+"";
//将数据存入队列中
boolean offer = blockingQueue.offer(data, 2, TimeUnit.SECONDS);
if (offer) {
System.out.println("生产者存入数据" + data + "到队列中成功");
}else {
System.out.println("生产者存入数据" + data + "到队列中失败");
}
Thread.sleep(1000);
}
} catch (Exception e) {
// TODO: handle exception
} finally {
System.out.println("生产者退出线程");
}
}
public void stop() {
this.flag = false;
}

}

//内部类：消费者
public class Consumer implements Runnable{
private BlockingQueue<String> blockingQueue;
private volatile boolean flag = true;
public Consumer(BlockingQueue<String> blockingQueue) {//构造函数
this.blockingQueue = blockingQueue;
}
@Override
public void run() {
System.out.println("消费者线程启动");
try {
while (flag) {
System.out.println("消费者正在从队列中获取数据");
String data = blockingQueue.poll(2, TimeUnit.SECONDS);
if (data != null) {
System.out.println("消费者拿到队列中的数据：" + data);
}else {
System.out.println("消费者超过2秒钟没有获取到数据");
flag = false;
}
}
} catch (Exception e) {
// TODO: handle exception
} finally {
System.out.println("消费者退出线程");
}
}
}

//main函数
public static void main(String[] args) throws InterruptedException {
BlockingQueueTest blockingQueueTest = new BlockingQueueTest();
BlockingQueue<String> linkedBlockingQueue = new LinkedBlockingQueue<String>(10);
Producer producer = blockingQueueTest.new Producer(linkedBlockingQueue);
Producer producer2 = blockingQueueTest.new Producer(linkedBlockingQueue);
Consumer consumer = blockingQueueTest.new Consumer(linkedBlockingQueue);
new Thread(producer).start();
new Thread(producer2).start();
new Thread(consumer).start();
Thread.sleep(10 * 1000);
producer.stop();
producer2.stop();
}
}

四、ArrayBlockingQueue
1. 介绍
ArrayBlockingQueue是一个有边界的阻塞队列，它的内部实现是一个数组。有边界的意思是它的容量是有限的，我们必须在其初始化的时候指定它的容量大小，容量大小一旦指定就不可改变。
ArrayBlockingQueue是以先进先出的方式存储数据，最新插入的对象是尾部，最新移出的对象是头部。

2. 运行效果：

3. Java代码：

@Test
public void TestArrayBlockingQueue() throws InterruptedException {
ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<String>(2);
arrayBlockingQueue.add("大都督");
arrayBlockingQueue.add("小乔");
arrayBlockingQueue.offer("user", 7, TimeUnit.SECONDS);
}

五、LinkedBlockingQueue
1.介绍
LinkedBlockingQueue阻塞队列大小的配置是可选的，如果我们初始化时指定一个大小，它就是有边界的，如果不指定，它就是无边界的。说是无边界，其实是采用了默认大小为Integer.MAX_VALUE的容量。它的内部实现是一个链表。

2. 运行结果：

3. Java代码

@Test
public void TestLinkedBlockingQueue() throws InterruptedException {
LinkedBlockingQueue<String> linkedBlockingQueue = new LinkedBlockingQueue<String>();
linkedBlockingQueue.add("大都督");
linkedBlockingQueue.add("大都督");
linkedBlockingQueue.add("大都督");
System.out.println("size:" + linkedBlockingQueue.size());
}

六、PriorityBlockingQueue
1. 介绍
PriorityBlockingQueue是一个没有边界的队列，它的排序规则和 java.util.PriorityQueue一样。需要注
意，PriorityBlockingQueue中允许插入null对象。
所有插入PriorityBlockingQueue的对象必须实现 java.lang.Comparable接口，队列优先级的排序规则就
是按照我们对这个接口的实现来定义的。
另外，我们可以从PriorityBlockingQueue获得一个迭代器Iterator，但这个迭代器并不保证按照优先级顺
序进行迭代。

七、SynchronousQueue
1. 介绍
SynchronousQueue队列内部仅允许容纳一个元素。当一个线程插入一个元素后会被阻塞，除非这个元素被另一个线程消费。

来源：https://www.cnblogs.com/rzbwyj/p/12554142.html

标签

优先级队列

线程阻塞

string