JAVA常用队列类

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 queue = new ArrayBlockingQueue(1024); 
 queue.put("1"); //向队列中添加元素 
 Object object = queue.take(); //从队列中取出元素

//数据元素数组 
 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(); 
 }

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();
}

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;
}

//指定队列的大小创建有界队列 
BlockingQueue<Integer> boundedQueue = new LinkedBlockingQueue<>(100); 
//无界队列 
BlockingQueue<Integer> unboundedQueue = new 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); 
}