public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
    implements BlockingQueue<E> {
    //可重入锁
    private final transient ReentrantLock lock = new ReentrantLock();
    //存储元素的优先级队列
    private final PriorityQueue<E> q = new PriorityQueue<E>();
    //等待队列头部元素的指定线程
    private Thread leader = null;
    //条件控制，表示是否可以从队列中取数据
    private final Condition available = lock.newCondition();
}

public class PriorityBlockingQueue<E> extends AbstractQueue<E>
    implements BlockingQueue<E>, java.io.Serializable {
    
    //队列默认大小
    private static final int DEFAULT_INITIAL_CAPACITY = 11;  
    //队列最大容量，超过该容量抛OutOfMemoryError异常
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    //优先级队列表示为平衡二叉堆。queue[0]为元素最小值。PriorityBlockingQueue 底层还是通过数组来实现的
    private transient Object[] queue;
    //队列元素个数 不序列化
    private transient int size;
    //比较器。在为null时使用元素的自然排序
    private transient Comparator<? super E> comparator;
    //用于队列操作的锁
    private final ReentrantLock lock;
    //队列非空条件
    private final Condition notEmpty;
    //队列扩容的 "锁" 不序列化
    private transient volatile int allocationSpinLock;
    //队列扩容的 "锁" 不序列化
    private transient volatile int allocationSpinLock;
}

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {
    /** 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;
       
}

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    
    final transient ReentrantLock lock = new ReentrantLock();
    /** The array, accessed only via getArray/setArray. */
    //底层数据结构。并被volatile修饰
    private transient volatile Object[] array;
}

//默认创建一个元素数为0的数组，ArrayList则默认为10
public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}

public CopyOnWriteArrayList(Collection<? extends E> c) {
    Object[] elements;
    if (c.getClass() == CopyOnWriteArrayList.class)
        elements = ((CopyOnWriteArrayList<?>)c).getArray();
    else {
        elements = c.toArray();
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elements.getClass() != Object[].class)
            elements = Arrays.copyOf(elements, elements.length, Object[].class);
    }
    setArray(elements);
}

public CopyOnWriteArrayList(E[] toCopyIn) {
    setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}

public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
        implements Queue<E>, java.io.Serializable {
        
    //内部节点类
    private static class Node<E> {
        volatile E item;    //表示元素
        volatile Node<E> next;  //表示下一个结点
    }
    
    private transient volatile Node<E> head;    //头结点
    private transient volatile Node<E> tail;    //尾节点
    
    //遍历器类
    private class Itr implements Iterator<E> {
        /**
         * Next node to return item for.
         */
        private Node<E> nextNode;

        /**
         * nextItem holds on to item fields because once we claim
         * that an element exists in hasNext(), we must return it in
         * the following next() call even if it was in the process of
         * being removed when hasNext() was called.
         */
        private E nextItem;

        /**
         * Node of the last returned item, to support remove.
         */
        private Node<E> lastRet;
    }
}