JUC——阻塞队列
Queue是一个队列，而队列的主要特征是FIFO先进先出，要实现生产者与消费者模型，也可以采用队列来进行中间的缓冲读取，好处是：生产者可以一直不停歇的生产数据。
BlockingQueue是Queue的子类，它实现有队列的基本特征：
public interface BlockingQueue<E> extends Queue<E>
在最初利用Queue实现生产者与消费者模型的时候发现一个问题：所有的消费者可能不是一个轮流操作，而是有可能某一个消费者长期进行消费处理。
阻塞队列
BlockingQueue通常用于一个线程生成对象，而另外一个线程消费这些对象的场景。
一个线程将会持续生成新对象并将其插入到队列之中，直到队列达到它所能容纳的临界点，也就是说，它是有限的。如果该阻塞队列到达了临界点，负责生产的线程将会再往里面插入新对象时发生阻塞。它会一直处于阻塞之中，直到负责消费的线程从队列中拿走一个对象。
BlockingQueue也是一个处理接口， 如果要想操作BlockingQueue也需要使用它的一系列子类：
对于阻塞队列而言最基础的两个实现子类：数组的队列，链表的队列。
范例：使用BlockingQueue实现一个消费者与生产者模型
package so.strong.mall.concurrent;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
public class QueueDemo {
public static void main(String[] args) {
final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(5);//允许保存5个数据队列
for (int i = 0; i < 3; i++) { //3个生产者
new Thread(new Runnable() {
@Override
public void run() {
for (int j = 0; j < 5; j++) {
try {
TimeUnit.SECONDS.sleep(j);
String str = "[生产数据{" + Thread.currentThread().getName() + "}] j = " + j;
queue.put(str); //会进入到生产的阻塞状态
System.out.println(str);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}, "生产者-" + i).start();
}
for (int i = 0; i < 5; i++) { //5个消费者
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
TimeUnit.SECONDS.sleep(2);
if (queue.isEmpty()) { //队里内容为空
break;
}
System.out.println("[消费数据{" + Thread.currentThread().getName() + "}]" + queue.take());
} catch (Exception e) {
e.printStackTrace();
}
}
}
}, "消费者-" + i).start();
}
}
}
除了数组之外也可以使用链表来进行操作：LinkedBlockingQueue。在使用这个类进行BlockingQueue接口对象实例化的时候，如果没有设置容量，则容量为：Integer.MAX_VALUE。
范例：修改为链表实现消费者与生产者模型
final BlockingQueue<String> queue = new LinkedBlockingQueue<>(5);//允许保存5个数据队列
链表是通过索引在进行弹出数据的，而链表只需要弹出第一个元素即可。
范例：采用优先级的PriorityBlockingQueue来实现数据操作
public class PriorityBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable
PriorityBlockingQueue利用了Comparable接口来进行处理完成。
final BlockingQueue<String> queue = new PriorityBlockingQueue<>(5);//允许保存5个数据队列
对于使用哪一种具体的子类完全是由具体的开发环境来决定的。需要至少知道BlockingQueue这个阻塞队列核心就是提供有同步队列的功能。
SychronousQueue同步队列
之前使用的BlockingQueue每一次都可以保存多个数据对象信息，但是有些时候只能够允许保存一个数据的信息，这种情况下就要使用SychronousQueue子类来完成、
范例：使用同步队列来进行处理
package so.strong.mall.concurrent;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
public class QueueDemo {
public static void main(String[] args) {
final BlockingQueue<String> queue = new SynchronousQueue<>();//允许保存5个数据队列
for (int i = 0; i < 3; i++) { //3个生产者
new Thread(new Runnable() {
@Override
public void run() {
for (int j = 0; j < 5; j++) {
try {
TimeUnit.SECONDS.sleep(j);
String str = "[生产数据{" + Thread.currentThread().getName() + "}] j = " + j;
queue.put(str); //会进入到生产的阻塞状态
System.out.println(str);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}, "生产者-" + i).start();
}
for (int i = 0; i < 5; i++) { //5个消费者
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
TimeUnit.SECONDS.sleep(2);
System.out.println("[消费数据{" + Thread.currentThread().getName() + "}]" + queue.take());
} catch (Exception e) {
e.printStackTrace();
}
}
}
}, "消费者-" + i).start();
}
}
}
现在不关心有多少个消费者与生产者，都采用一个接一个的形式执行。
BlockingDeque双端阻塞队列
BlockingQueue主要特征是只能够从一方面获取数据，也就是说它按照一个队列的形式采用了FIFO处理完成。但是现在希望可以按照前后各自处理，那么就需要BlocingDeque。
一个BlockingDeque线程在双端队列的两端都可以插入数据和提取数据。
一个线程生产元素，并把它们插入到队列的任意一端。如果双端队列已满，插入线程将被阻塞，直到一个移除线程从该队列中移除了一个元素。如果双端队列为空，移除线程将被阻塞，直到一个插入线程向该队列插入了一个新元素。
BlockingDeque接口结构：
public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E>
子类LinkedBlockingDeque类结构
public class LinkedBlockingDeque<E> extends AbstractQueue<E> implements BlockingDeque<E>, java.io.Serializable
范例：观察双端队列的基本使用
package so.strong.mall.concurrent;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;
/**
* @author Termis
* @date 2018/5/21
*/
public class QueueDemo {
public static void main(String[] args) {
final BlockingDeque<String> deque = new LinkedBlockingDeque<>();
for (int i = 0; i < 3; i++) {
new Thread(new Runnable() {
@Override
public void run() {
for (int j = 0; j < 5; j++) {
try {
TimeUnit.SECONDS.sleep(1);
String str;
if (j % 2 == 0) {
str = "[FIRST]生产数据{" + Thread.currentThread().getName() + "}y=" + j;
deque.addFirst(str);
} else {
str = "[LAST]生产数据{" + Thread.currentThread().getName() + "}y=" + j;
deque.addLast(str);
}
System.out.println(str);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}, "生产者-" + i).start();
}
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
TimeUnit.SECONDS.sleep(2);
System.out.println("[First]消费数据{" + Thread.currentThread().getName() + "}" + deque.takeFirst());
} catch (Exception e) {
e.printStackTrace();
}
}
}
}, "消费者First").start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
TimeUnit.SECONDS.sleep(2);
System.out.println("[Last]消费数据{" + Thread.currentThread().getName() + "}" + deque.takeLast());
} catch (Exception e) {
e.printStackTrace();
}
}
}
}, "消费者Last").start();
}
}
生产者和消费者模型的实现方案很多。对于双端队列一定清楚它本身还是一个队列。如果现在first已经拽干净了，那么就继续拽last，就会有可能出现first消费last的情况。
public class QueueDemo {
public static void main(String[] args) throws Exception {
BlockingDeque<String> deque = new LinkedBlockingDeque<>();
deque.addFirst("hello-first");
deque.addFirst("world-first");
deque.addLast("hello-last");
deque.addLast("world-last");
System.out.println(deque.takeFirst());
System.out.println(deque.takeFirst());
System.out.println(deque.takeFirst());
System.out.println(deque.takeFirst());
}
}
world-first hello-first hello-last world-last
如果一端出现了阻塞，那么至少另外一端可以继续使用。
下一篇： 传谷歌开发新智能通讯应用：整合聊天机器人