队列实质就是一种存储数据的结构 通常用链表或者数组实现 一般而言队列具备FIFO先进先出的特性，当然也有双端队列（Deque）优先级队列 主要操作：入队（EnQueue）与出队（Dequeue）

BlockingQueue

队列实质就是一种存储数据的结构 通常用链表或者数组实现 一般而言队列具备FIFO先进先出的特性，当然也有双端队列（Deque）优先级队列 主要操作：入队（EnQueue）与出队（Dequeue）

1、ArrayBlockingQueue 由数组支持的有界队列

2、LinkedBlockingQueue 由链接节点支持的可选有界队列

3、PriorityBlockingQueue 由优先级堆支持的无界优先级队列

4、DelayQueue 由优先级堆支持的、基于时间的调度队列

BlockingQueue底层依赖ReenTrantLock 和Condition（条件队列只能在独占模式下使用，共享模式不能用）(AQS框架实现)

ArrayBlockingQueue

 BlockingQueue<Ball> blockingQueue = new ArrayBlockingQueue<Ball>(1);初始化源码分析

 public ArrayBlockingQueue(int capacity) {
        this(capacity, false); -------------false默认创建时非公平锁
    }

public ArrayBlockingQueue(int capacity, boolean fair) {
    if (capacity <= 0)
        throw new IllegalArgumentException();
    this.items = new Object[capacity];-------初始化数组
    lock = new ReentrantLock(fair);------创建非公平锁
    notEmpty = lock.newCondition();   ---------------初始化了两个条件队列，对应两个条件对列notEmpty ,notFull 
  
    notFull =  lock.newCondition();

}
// 两个条件队列如下图：


为什么会有连两个条件队列，因为有put(生产者)，和take(消费者) 两个操作 put的时候要看（Notfull）是不是满了，take(Notempty)是看是不是空了。
put生产者操作源码解读

public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();  //----先上来获取独占锁，才能进入下面的逻辑。
    try {
        while (count == items.length)
            notFull.await();       // 判断当前队列是不是已经满了，如果count == items.length，那么这个下线程就要入条件队列等待

        enqueue(e);
    } finally {
        lock.unlock();
    }
}

/**
 * 加入条件队列等待，条件队列入口
 */
public final void await() throws InterruptedException {
    //如果当前线程被中断则直接抛出异常
    if (Thread.interrupted())
        throw new InterruptedException();
    //把当前节点加入条件队列
    Node node = addConditionWaiter();
    //释放掉已经获取的独占锁资源
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    //如果不在同步队列中则不断挂起
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this);
        //这里被唤醒可能是正常的signal操作也可能是中断
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    /**
     * 走到这里说明节点已经条件满足被加入到了同步队列中或者中断了
     * 这个方法很熟悉吧？就跟独占锁调用同样的获取锁方法，从这里可以看出条件队列只能用于独占锁
     * 在处理中断之前首先要做的是从同步队列中成功获取锁资源
     */
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    //走到这里说明已经成功获取到了独占锁，接下来就做些收尾工作
    //删除条件队列中被取消的节点
    if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();
    //根据不同模式处理中断
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

/**
 * 这里的判断逻辑是：
 * 1.如果现在不是中断的，即正常被signal唤醒则返回0
 * 2.如果节点由中断加入同步队列则返回THROW_IE，由signal加入同步队列则返回REINTERRUPT
 */
private int checkInterruptWhileWaiting(Node node) {
    return Thread.interrupted() ?
            (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
            0;
}

// 这个方法是把条件节点转运到CLH同步队列中并把信号量置为初始值0，返回转运成功与否标志。只有把条件节点转运到同步队列才又可能被唤醒。

final boolean transferAfterCancelledWait(Node node) {
    if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
        enq(node);
        return true;
    }
    /*
     * If we lost out to a signal(), then we can"t proceed
     * until it finishes its enq().  Cancelling during an
     * incomplete transfer is both rare and transient, so just
     * spin.
     */
    while (!isOnSyncQueue(node))
        Thread.yield();
    return false;
}