《JAVA基础》-- Lambda表达式及Stream的使用JAVA常用队列类

阻塞队列介绍

Queue接口

public interface Queue<E> extends Collection<E> { 
 //添加一个元素，添加成功返回true, 如果队列满了，就会抛出异常 
 boolean add(E e); 
 //添加一个元素，添加成功返回true, 如果队列满了，返回false 
 boolean offer(E e); 
 //返回并删除队首元素，队列为空则抛出异常 
 E remove();
 //返回并删除队首元素，队列为空则返回null 
 E poll(); 
 //返回队首元素，但不移除，队列为空则抛出异常 
 E element(); 
 //获取队首元素，但不移除，队列为空则返回null 
 E peek(); 
}

BlockingQueue接口

BlockingQueue 继承了 Queue 接口，是队列的一种。Queue 和 BlockingQueue 都是在 Java5 中加入的。 阻塞队列（BlockingQueue）是一个在队列基础上又支持了两个附加操作的队列 ，常用解耦。两个附加操作:

• 支持阻塞的插入方法put: 队列满时，队列会阻塞插入元素的线程，直到队列不满。
• 支持阻塞的移除方法take: 队列空时，获取元素的线程会等待队列变为非空

BlockingQueue和JDK集合包中的Queue接口兼容，同时在其基础上增加了阻塞功能。

入队：

（1）offer(E e)：如果队列没满，返回true，如果队列已满，返回false（不阻塞）

（2）offer(E e, long timeout, TimeUnit unit)：可以设置阻塞时间，如果队列已满，则进行阻塞。超过阻塞时间，则返回false

（3） put(E e) ： 队列没满的时候是正常的插入，如果队列已满，则阻塞，直至队列空出位置

出队：

（1）poll()：如果有数据，出队，如果没有数据，返回null （不阻塞）

（2）poll(long timeout, TimeUnit unit)：可以设置阻塞时间，如果没有数据，则阻塞，超过阻塞时间，则返回null

（3） take() ： 队列里有数据会正常取出数据并删除；但是如果队列里无数据，则阻塞，直到队列里有数据

BlockingQueue常用方法示例

当队列满了无法添加元素，或者是队列空了无法移除元素时：

1. 抛出异常：add、remove、element

2. 返回结果但不抛出异常：offer、poll、peek

3. 阻塞：put、take

阻塞队列特性

阻塞

阻塞队列区别于其他类型的队列的最主要的特点就是“阻塞”这两个字，所以下面重点介绍阻塞功能： 阻塞功能使得生产者和消费者两端的能力得以平衡，当有任何一端速度过快时，阻塞队列便会把过快的速度给降下来。 实现阻塞最重要的两个方法是 take 方法和 put 方法。

take 方法

take 方法的功能是获取并移除队列的头结点，通常在队列里有数据的时候是可以正常移除的。 可是一旦执行 take 方法的时候，队列里无数据，则阻塞 ，直到队列里有数据。一旦队列里有数据了，就会立刻解除阻塞状态，并且取到数据。

put 方法

put 方法插入元素时，如果队列没有满，那就和普通的插入一样是正常的插入， 但是如果队列已满，那么就无法继续插入，则阻塞 ，直到队列里有了空闲空间。如果后续队列有了空闲空间，比如消费者消费了一个元素，那么此时队列就会解除阻塞状态，并把需要添加的数据添加到队列中。

是否有界

阻塞队列还有一个非常重要的属性，那就是 容量的大小，分为有界和无界两种。 无界队列意味着里面可以容纳非常多的元素，例如 LinkedBlockingQueue 的上限是Integer.MAX_VALUE，是非常大的一个数，可以近似认为是无限容量，因为我们几乎无法把这个容量装满。但是有的阻塞队列是有界的，例如 ArrayBlockingQueue 如果容量满了，也不会扩容，所以一旦满了就无法再往里放数据了。

应用场景

     BlockingQueue 是线程安全的，我们在很多场景下都可以利用线程安全的队列来优雅地解决我们业务自身的线程安全问题。 比如说，使用生产者/消费者模式的时候，我们生产者只需要往队列里添加元素，而消费者只需要从队列里取出它们就可以了。

     因为阻塞队列是线程安全的，所以生产者和消费者都可以是多线程的，不会发生线程安全问题。 生产者/消费者直接使用线程安全的队列就可以 ，而不需要自己去考虑更多的线程安全问题。这也就意味着，考虑锁等线程安全问题的重任从“你”转移到了“队列”上， 降低了我们开发的难度和工作量。

      同时， 队列它还能起到一个隔离的作用。 比如说我们开发一个银行转账的程序，那么生产者线程不需要关心具体的转账逻辑，只需要把转账任务，如账户和金额等信息放到队列中就可以，而不需要去关心银行这个类如何实现具体的转账业务。而作为银行这个类来讲，它会去从队列里取出来将要执行的具体的任务，再去通过自己的各种方法来完成本次转账。这样就 实现了具体任务与执行任务类之间的解耦 ，任务被放在了阻塞队列中，而负责放任务的线程是无法直接访问到我们银行具体实现转账操作的对象的 ，实现了隔离，提高了安全性。

常见阻塞队列

BlockingQueue 接口的实现类都被放在了 juc 包中，它们的区别主要体现在存储结构上或对元

素操作上的不同，但是对于take与put操作的原理，却是类似的。

队列	描述
ArrayBlockingQueue	基于数组结构实现的一个有界阻塞队列
LinkedBlockingQueue	基于链表结构实现的一个有界阻塞队列
PriorityBlockingQueue	支持按优先级排序的无界阻塞队列
DelayQueue	基于优先级队列（PriorityBlockingQueue）实现的无界阻塞队列
SynchronousQueue	不存储元素的阻塞队列
LinkedTransferQueue	基于链表结构实现的一个无界阻塞队列
LinkedBlockingDeque	基于链表结构实现的一个双端阻塞队列

ArrayBlockingQueue

      ArrayBlockingQueue是最典型的有界阻塞队列，其内部是用数组存储元素的，初始化时需要指定容量大小，利用 ReentrantLock 实现线程安全。

     在生产者-消费者模型中使用时， 如果生产速度和消费速度基本匹配的情况下，使用ArrayBlockingQueue是个不错选择 ；当如果生产速度远远大于消费速度，则会导致队列填满，大量生产线程被阻塞。

     使用独占锁ReentrantLock实现线程安全，入队和出队操作使用同一个锁对象，也就是只能有一个线程可以进行入队或者出队操作；这也就意味着生产者和消费者无法并行操作，在高并发场景下会成为性能瓶颈。

ArrayBlockingQueue使用

 BlockingQueue queue = new ArrayBlockingQueue(1024); 
 queue.put("1"); //向队列中添加元素 
 Object object = queue.take(); //从队列中取出元素

ArrayBlockingQueue的原理

数据结构

利用了Lock锁的Condition通知机制进行阻塞控制。

核心：一把锁，两个条件

 //数据元素数组 
 final Object[] items; 
 //下一个待取出元素索引 
 int takeIndex; 
 //下一个待添加元素索引 
 int putIndex; 
 //元素个数 
 int count; 
 //内部锁 
 final ReentrantLock lock; 
 //消费者 
 private final Condition notEmpty; 
 //生产者 
 private final Condition notFull; 
 public ArrayBlockingQueue(int capacity) { 
   this(capacity, false); 
 } 
 public ArrayBlockingQueue(int capacity, boolean fair) { 
   lock = new ReentrantLock(fair); //公平，非公平 
   notEmpty = lock.newCondition(); 
   notFull = lock.newCondition(); 
 }

入队put方法

public void put(E e) throws InterruptedException {
    //检查是否为空
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    //加锁，如果线程中断抛出异常
    lock.lockInterruptibly();
    try {
        //阻塞队列已满，则将生产者挂起，等待消费者唤醒 
        //设计注意点： 用while不用if是为了防止虚假唤醒
        while (count == items.length)
            notFull.await(); //队列满了，使用notFull等待（生产者阻塞）
        // 入队
        enqueue(e);
    } finally {
        // 唤醒消费者线程
        lock.unlock();
    }
}

private void enqueue(E x) {
    // assert lock.getHoldCount() == 1;
    // assert items[putIndex] == null;
    final Object[] items = this.items;
//入队 使用的putIndex
    items[putIndex] = x;
    if (++putIndex == items.length)
        putIndex = 0; //设计的精髓： 环形数组，putIndex指针到数组尽头了，返回头部
    count++;
//notEmpty条件队列转同步队列，准备唤醒消费者线程，因为入队了一个元素，肯定不为空了
    notEmpty.signal();
}

出队take方法

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == 0)
            notEmpty.await();
        return dequeue();
    } finally {
        lock.unlock();
    }
}

private E dequeue() {
    // assert lock.getHoldCount() == 1;
    // assert items[takeIndex] != null;
    final Object[] items = this.items;
    @SuppressWarnings("unchecked")
    E x = (E) items[takeIndex];//取出takeIndex位置的元素
    items[takeIndex] = null;
    if (++takeIndex == items.length)
        takeIndex = 0;//设计的精髓： 环形数组，takeIndex 指针到数组尽头了，返回头部
    count--;
    if (itrs != null)
        itrs.elementDequeued();
    //notFull条件队列转同步队列，准备唤醒生产者线程，此时队列有空位
    notFull.signal();
    return x;
}

 设计总结：

•   基于数组的有界队列
•   出队入队共用一把锁ReentrantLock，两个条件newCondition
•   环形数组，读写各一个指针
•    while循环防止虚假唤醒

LinkedBlockingQueue

      LinkedBlockingQueue是一个基于链表实现的阻塞队列 ，默认情况下，该阻塞队列的大小为Integer.MAX_VALUE，由于这个数值特别大，所以 LinkedBlockingQueue 也被称作无界队列 ，代表它几乎没有界限， 队列可以随着元素的添加而动态增长， 但是 如果没有剩余内存，则队列将抛出OOM错误。 所以 为了避免队列过大造成机器负载或者内存爆满的情况出现，我们在使用的时候建议手动传一个队列的大小。

      LinkedBlockingQueue内部由单链表实现，只能从head取元素，从tail添加元素。

      LinkedBlockingQueue采用两把锁的锁分离技术实现入队出队互不阻塞，添加元素和获取元素都有独立的锁，也就是说LinkedBlockingQueue是读写分离的，读写操作可以并行执行。

LinkedBlockingQueue使用

//指定队列的大小创建有界队列 
BlockingQueue<Integer> boundedQueue = new LinkedBlockingQueue<>(100); 
//无界队列 
BlockingQueue<Integer> unboundedQueue = new LinkedBlockingQueue<>();

LinkedBlockingQueue的原理

数据结构

// 容量,指定容量就是有界队列 
private final int capacity; 
// 元素数量 
private final AtomicInteger count = new AtomicInteger(); 
// 链表头 本身是不存储任何元素的，初始化时item指向null 
transient Node<E> head; 
// 链表尾 
private transient Node<E> last; 
// take锁 锁分离，提高效率 
private final ReentrantLock takeLock = new ReentrantLock(); 
// notEmpty条件 
// 当队列无元素时，take锁会阻塞在notEmpty条件上，等待其它线程唤醒 
private final Condition notEmpty = takeLock.newCondition(); 
// put锁 
private final ReentrantLock putLock = new ReentrantLock(); 
// notFull条件 
// 当队列满了时，put锁会会阻塞在notFull上，等待其它线程唤醒 
private final Condition notFull = putLock.newCondition(); 
//典型的单链表结构 
static class Node<E> { 
  E item; //存储元素 
  Node<E> next; //后继节点 单链表结构 
  Node(E x) { item = x; } 
}

构造器

public LinkedBlockingQueue() { 
// 如果没传容量，就使用最大int值初始化其容量 
 this(Integer.MAX_VALUE); 
} 
public LinkedBlockingQueue(int capacity) { 
  if (capacity <= 0) throw new IllegalArgumentException(); 
  this.capacity = capacity; 
  // 初始化head和last指针为空值节点 
  last = head = new Node<E>(null); 
}