Java源码之阻塞队列

⑴背景

阻塞队列常用于生产者消费者场景，生产者是向队列里添加元素的线程，消费者是向队列里取出元素的线程。阻塞队列的角色是供生产者存放元素，消费者取出元素的容器。

⑵阻塞队列

阻塞队列是一个支持两个附加操作的队列。（支持阻塞插入和移除方法）

①阻塞插入：当队列满时，队列会阻塞插入元素的线程，直到队列不满。

②阻塞移除：当队列空时，获取元素的线程会等待队列变为空。

  /** The queued items */
     final Object[] items;

     /** items index for next take, poll, peek or remove */
     int takeIndex;

     /** items index for next put, offer, or add */
     int putIndex;

     /** Number of elements in the queue */
     int count;

     /*
      * Concurrency control uses the classic two-condition algorithm
      * found in any textbook.
      */

     /** Main lock guarding all access */
     final ReentrantLock lock;

     /** Condition for waiting takes */
     private final Condition notEmpty;

     /** Condition for waiting puts */
     private final Condition notFull;

 /**
      * 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) {           //当队列容量小于等于0，会抛异常。当队列满时再继续插入，也会抛该异常
         if (capacity <= 0)
             throw new IllegalArgumentException();           //创建容量数组
         this.items = new Object[capacity];           //创建可重入锁与阻塞条件
         lock = new ReentrantLock(fair);
         notEmpty = lock.newCondition();
         notFull =  lock.newCondition();
     }

 /**
      * 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;           //lockInterruptibly()允许在等待时由其他线程的Thread.interrupt()方法来中断等待线程而直接返回，这时是不用获取锁的，而会抛出一个InterruptException。           //而ReentrantLock.lock()方法则不允许Thread.interrupt()中断，即使检测到了Thread.interruptted一样会继续尝试获取锁，失败则继续休眠。只是在最后获取锁成功之后在把当前线程置为interrupted状态。
         lock.lockInterruptibly();
         try {               //当队列满时，阻塞插入队列的线程
             while (count == items.length)
                 notFull.await();               //对列不满就入队列
             enqueue(e);
         } finally {               //最后必须释放锁资源
             lock.unlock();
         }
     }

 public E take() throws InterruptedException {
         final ReentrantLock lock = this.lock;           //加锁保证只有一个线程进入take方法
         lock.lockInterruptibly();
         try {               //当队列为空时，阻塞取出元素的线程
             while (count == 0)
                 notEmpty.await();               //当队列队列非空时，允许元素加入队列
             return dequeue();
         } 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)  //当索引等于数组最大值时，索引置0
             putIndex = 0;
         count++;
         notEmpty.signal();  //使用条件对象notEmpty通知，当调用take,poll,remove时，线程被阻塞，对列为空，当调用enqueue时，队列不为空了，使用signal函数进行通知
     }

 /**
      * 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();
         return x;
     }

该博客更详细，向博主学习，以后更深入学习后再来完善这篇博客。http://blog.csdn.net/x_i_y_u_e/article/details/52513038