并发队列

并发队列

ConcurrentLinkedQueue（非阻塞式队列）、BlockingQueue（阻塞式队列）

区别：

入列：阻塞式队列入队，超过队列总数，会阻塞（进行等待）。
出列：阻塞式队列出列，队列为空时，会阻塞（进行等待）。

队列：先进先出、后进后出
栈：先进后出，后进先出

非阻塞队列

ArrayDeque、PriorityQueue、ConcurrentLinkedQueue

阻塞队列

DelayQueue、ArrayBlockingQueue、LinkedBlockingQueue、PriprityBlockingQueue、SynchronousQueue

ConcurrentLinkedQueue

ConcurrentLinkedQueue：是一个适用于高并发场景下的队列，通过无锁的方式，实现了高并发状态下的高性能，通常ConcurrentLinkedQueue性能好于BlockingQueue。它是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。该队列不允许null元素。
ConcurrentLinkedQueue重要方法：
add()和offer()都是加入元素的方法（在ConcurrentLinkedQueue中这两个方法没有任何区别）
poll()和peek()都是取头元素节点，poll()会删除元素，peek()不会

package com.xiaoming.day04;

import java.util.concurrent.ConcurrentLinkedQueue;
/**
 * @Author:         xiaoming
 * @CreateDate:     2019/6/16 22:43
 * @Description:    阻塞式队列最大好处，能够防止队列容器溢出，防止丢失数据。
 *                  先进先出，后进后出
 */
public class Test001 {

    public static void main(String[] args) {
        //非阻塞式队列， 无界队列
        ConcurrentLinkedQueue<String> concurrentLinkedQueue = new ConcurrentLinkedQueue<String>();
        concurrentLinkedQueue.offer("张三");
        concurrentLinkedQueue.offer("李四");
        concurrentLinkedQueue.offer("小明");
        //获取队列 只能获取一个队列元素，并且删除该元素
        System.out.println(concurrentLinkedQueue.poll());
        //获取队列 只能获取一个队列元素，不会删除该元素，一般不会用该方法
        System.out.println(concurrentLinkedQueue.peek());
        //获取队列的个数
        System.out.println(concurrentLinkedQueue.size());
    }

}

BlockingQueue

阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：
在队列为空时，获取元素的线程会等待队列变为非空。
当队列满时，存储元素的线程会等待队列可用。
阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。
BlockingQueue即阻塞队列，从阻塞这个词可以看出，在某些情况下对阻塞队列的访问可能会造成阻塞。被阻塞的情况主要有如下两种：

1. 当队列满了的时候进行入队列操作
2. 当队列空了的时候进行出队列操作
   因此，当一个线程试图对一个已经满了的队列进行入队列操作时，它将会被阻塞，除非有另一个线程做了出队列操作；同样，当一个线程试图对一个空队列进行出队列操作时，它将会被阻塞，除非有另一个线程进行了入队列操作。

ArrayBlockingQueue

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

package com.xiaoming.day04;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
/**
 * @Author:         xiaoming
 * @CreateDate:     2019/6/16 23:00
 * @Description:    阻塞式队列，如果存队列的时候，如果满了，就会等待
 *                  如果获取不到，也会等待
 */
public class Test002 {

    public static void main(String[] args) throws InterruptedException {
        //最多支持队列总数  阻塞式队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);
        //添加非阻塞式队列
        blockingQueue.offer("张三");
        //添加阻塞式队列
        blockingQueue.offer("李四", 3, TimeUnit.SECONDS);
        //添加非阻塞式队列
        blockingQueue.offer("小明");
        //添加阻塞式队列
        boolean offer = blockingQueue.offer("佩佩", 3, TimeUnit.SECONDS);

        //前面这段代码运行需要 3 秒， 佩佩需要等待， 如果没有人取。佩佩存不进去， 会丢失
        System.out.println(offer);

        System.out.println(blockingQueue.poll());
        //不会等待， 原因：队列没有满，能取到值，没有满
        System.out.println(blockingQueue.poll(3, TimeUnit.SECONDS));
        //会等待， 原因：队列为空，阻塞 3 秒
        System.out.println(blockingQueue.poll(3, TimeUnit.SECONDS));
    }

}

LinkedBlockingQueue

LinkedBlockingQueue阻塞队列大小的配置是可选的，如果我们初始化时指定一个大小，它就是有边界的，如果不指定，它就是无边界的。说是无边界，其实是采用了默认大小为Integer.MAX_VALUE的容量 。它的内部实现是一个链表。
和ArrayBlockingQueue一样，LinkedBlockingQueue 也是以先进先出的方式存储数据，最新插入的对象是尾部，最新移出的对象是头部。

PriorityBlockingQueue

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

SynchronousQueue

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