java并发包——阻塞队列BlockingQueue及源码分析

一、摘要

　　BlockingQueue通常用于一个线程在生产对象，而另外一个线程在消费这些对象的场景，例如在线程池中，当运行的线程数目大于核心的线程数目时候，经常就会把新来的线程对象放到BlockingQueue中去。

二、阻塞队列原理

　　原理简单的来讲：就是一个线程往队列里面放，而另外的一个线程从里面取

　　当线程持续的产生新对象并放入到队列中，直到队列达到它所能容纳的临界点。注意，队列的容量是有限的，不可能一直往里面插入对象。如果队列到达了临界点时，这个时候再想往队列中插入元素则会产生阻塞，直到另一端从队列中进行消费了，这个时候阻塞现象才不会发生。另外当去消费一个空的队列时候，这个线程也会产生阻塞现象，直到一个线程把对象插入到队列中

三、BlockingQueue常用方法总结

	抛出异常	特殊值	阻塞	超时
插入	add(e)	offer(e)	put(e)	offer(e,time,unit)
移除	remove(e)	poll	take()	poll(time,unit)
检查	element(e)	peek	不可用	不可用

　　四组不同的行为方式解释：
　　　　1.  抛异常：如果试图的操作无法立即执行，抛一个异常。
　　　　2.  特定值：如果试图的操作无法立即执行，返回一个特定的值(常常是 true / false)。
　　　　3.  阻塞：如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行。
　　　　4.  超时：如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行，但等
　　　　　　待时间不会超过给定值。返回一个特定值以告知该操作是否成功(典型的是 true / false)。
　　　　　　无法向一个 BlockingQueue 中插入 null。如果你试图插入 null，BlockingQueue 将会抛出
　　　　　　一个 NullPointerException。

四、BlockingQueue源码分析

　　1、通过IDE可以明显的看到BlockingQueue是一个接口，我们在写代码的时候需要实现这个接口

　　　　java.util.concurrent 具有以下 BlockingQueue 接口的实现(Java 8)：

　　　　　　

五、数组阻塞队列ArrayBlockingQueue分析

　　1、原理分析

　　　　首先ArrayBlockingQueue 类实现了 BlockingQueue 接口。其次ArrayBlockingQueue 是一个有界的阻塞队列，其内部实现是将对象放到一个数组里，所以一旦创建了该队列，就不能再增加其容量了。最后ArrayBlockingQueue 内部以 FIFO(先进先出)的顺序对元素进行存储。

　　2、ArrayBlockingQueue的方法(下面着重分析put()和take()二者方法)

　　　　此构造方法中，我们能看到传入了两个参数，capacity代表着队列的容量大小，而boolean类型的参数则是判断是否为公平锁，如果为true，则先到的线程会先得到锁对象，　　　　反之则有操作系统去决定哪个线程获得锁，大多数情况下都是设置为false，这样性能会高点

　　　　在put方法中，我们能看到在执行put方法时，我们必须要对其进行加锁操作，从而保证线程的安全性。其次会去判断其队列是否饱满了，饱满时则会发生阻塞现象，直到被其他线程唤醒时插入元素，接着会去调用notEmpty.signal()方法，间接的利用take方法将队列中的元素取走，最后将锁释放。

　　     同理可以看出take()方法是相反的，不再做详细介绍，代码注释已给出

　　　　put()和take()精简源代码如下：

  /** The queued items */
     final Object[] items;　　　　　　//利用数组来存储元素
 　　/** Main lock guarding all access */
     final ReentrantLock lock;

     /** Condition for waiting takes */
     private final Condition notEmpty;  //定义一个Condition对象，用来对take进行操作

     /** Condition for waiting puts */
     private final Condition notFull;　　//定义一个Condition对象，用来对put进行操作

 /**
      * Creates an {@code ArrayBlockingQueue} with the given (fixed)
      * capacity and the specified access policy.
      *
      * @param capacity the capacity of this queue
      * @param fair if {@code true} then queue accesses for threads blocked
      *        on insertion or removal, are processed in FIFO order;
      *        if {@code false} the access order is unspecified.
      * @throws IllegalArgumentException if {@code capacity < 1}
      */
     public ArrayBlockingQueue(int capacity, boolean fair) {
         if (capacity <= 0)                    //判断初始化的容量大小
             throw new IllegalArgumentException();
         this.items = new Object[capacity];
         lock = new ReentrantLock(fair);
         notEmpty = lock.newCondition();
         notFull =  lock.newCondition();
     }
 ====================================put()方法==============================================
 　　/**
  * Inserts the specified element at the tail of this queue, waiting
  * for space to become available if the queue is full.
  *
  * @throws InterruptedException {@inheritDoc}
  * @throws NullPointerException {@inheritDoc}
  */
 public void put(E e) throws InterruptedException {
     checkNotNull(e);
     final ReentrantLock lock = this.lock;
     lock.lockInterruptibly();
     try {
         while (count == items.length)
             notFull.await();　　//队列饱满时，将使这个线程进入阻塞状态,直到被其他线程唤醒时插入元素
         enqueue(e);　　　　//将元素插入到队列中
     } finally {
         lock.unlock();
     }
 }

 　　/**
      * Inserts element at current put position, advances, and signals.
      * Call only when holding lock.
      */
     private void enqueue(E x) {
         // assert lock.getHoldCount() == 1;
         // assert items[putIndex] == null;
         final Object[] items = this.items;
         items[putIndex] = x;
         if (++putIndex == items.length)
             putIndex = 0;
         count++;
         notEmpty.signal();  //通知take那边消费其元素
     }
 　
 ===================================================take()方法========================================================
 　
 　public E take() throws InterruptedException {
     final ReentrantLock lock = this.lock;　　//加锁
     lock.lockInterruptibly();
     try {
         while (count == 0)
             notEmpty.await();　　//队列为空时，将使这个线程进入阻塞状态,直到被其他线程唤醒时取出元素
         return dequeue();　　//消费对头中的元素
     } finally {
         lock.unlock();
     }
 }

 　　/**
  * Extracts element at current take position, advances, and signals.
  * Call only when holding lock.
  */
 private E dequeue() {
     // assert lock.getHoldCount() == 1;
     // assert items[takeIndex] != null;
     final Object[] items = this.items;
     @SuppressWarnings("unchecked")
     E x = (E) items[takeIndex];
     items[takeIndex] = null;
     if (++takeIndex == items.length)
         takeIndex = 0;
     count--;
     if (itrs != null)
         itrs.elementDequeued();
     notFull.signal();　　//通知put那边消费其元素
     return x;
 }

六、链式阻塞队列LinkedBlockingQueue分析

　　1、原理分析

　　　　LinkedBlockingQueue 类实现了 BlockingQueue 接口。同时LinkedBlockingQueue 内部以一个链式结构(链接节点)对其元素进行存储。如果需要的话，这一链式结构可以选择一个上限。如果没有定义上限，将使用 Integer.MAX_VALUE 作为上限。LinkedBlockingQueue 内部以 FIFO(先进先出)的顺序对元素进行存储。

　　2、LinkedBlockingQueue方法分析

　　　　针对LinkedBlockingQueue的构造方法中，我们能看到没有定义上限时，会使用Integer.MAX_VALUE 作为上限

　　　　其次针对put等方法时，原理与ArrayBlockingQueue大致相同，只不过是基于链表去实现的

　　　　源码精简如下：

　　　　

  /** The capacity bound, or Integer.MAX_VALUE if none */
     //链表的容量
     private final int capacity;

     /** Current number of elements */
     //当前元素个数
     private final AtomicInteger count = new AtomicInteger();

     /**
      * Head of linked list.
      * Invariant: head.item == null
      */
     //链表头节点
     transient Node<E> head;

     /**
      * Tail of linked list.
      * Invariant: last.next == null
      */
     //链表尾节点
     private transient Node<E> last;

     /** Lock held by take, poll, etc */
     //出队列锁
     private final ReentrantLock takeLock = new ReentrantLock();

     /** Wait queue for waiting takes */
     private final Condition notEmpty = takeLock.newCondition();

     /** Lock held by put, offer, etc */
     //入队列锁
     private final ReentrantLock putLock = new ReentrantLock();

     /** Wait queue for waiting puts */
     private final Condition notFull = putLock.newCondition();

    //默认构造方法，默认执行容量上限
     public LinkedBlockingQueue() {
         this(Integer.MAX_VALUE);
     }

    //指定队列的容量
     public LinkedBlockingQueue(int capacity) {
         if (capacity <= 0) throw new IllegalArgumentException();
         this.capacity = capacity;
         //初始化头尾节点的值，设置均为null
         last = head = new Node<E>(null);
     }

     //往对尾中插入元素，队列满时，则会发生阻塞，直到有元素消费了或者线程中断了
      public void put(E e) throws InterruptedException {
         if (e == null) throw new NullPointerException();
         int c = -1;
         Node<E> node = new Node<E>(e);
         final ReentrantLock putLock = this.putLock;//入队列锁
         final AtomicInteger count = this.count;//获取当前队列中的元素个数
         putLock.lockInterruptibly();
         try {
             while (count.get() == capacity) { //条件：如果队列满了
                 notFull.await(); //则加入到出队列等待中，直到队列不满了，这时就会被其他线程notFull.signal()唤醒
             }
             enqueue(node);//将元素入队列
             c = count.getAndIncrement(); //对当前队列元素个数加1
             if (c + 1 < capacity)
                 notFull.signal();
         } finally {
             putLock.unlock();
         }
         if (c == 0)
             signalNotEmpty();
     }

     //出队列，大致原理与入队列相反，当队列为空时，则会阻塞，直到队列不为空或者线程中断
     public E take() throws InterruptedException {
         E x;
         int c = -1;
         final AtomicInteger count = this.count;
         final ReentrantLock takeLock = this.takeLock;
         takeLock.lockInterruptibly();
         try {
             while (count.get() == 0) {
                 notEmpty.await();
             }
             x = dequeue();
             c = count.getAndDecrement();
             if (c > 1)
                 notEmpty.signal();
         } finally {
             takeLock.unlock();
         }
         if (c == capacity)
             signalNotFull();
         return x;
     }

七、ArrayBlockingQueue和LinkedBlockingQueue源码比较

　　在上述源码过程我们能发现：

　　1、入队列时，当队列满了，则会发生阻塞，直到队列消费了数据或者线程被中断了才会唤醒

　　2、出队列时，当队列为空时，则会发生阻塞，直到队列中有数据了或者线程被中断了才会唤醒

　　源码注意：

　　　　ArrayBlockingQueue源码中，共用的是同一把锁

　　　　LinkedBlockingQueue源码中，则是用到了两把锁，一把是入队列锁，另一把是出队列锁

八、参考资料

　　https://www.cnblogs.com/java-zhao/p/5135958.html