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
如果一端出现了阻塞，那么至少另外一端可以继续使用。
