1、CopyOnWriteArrayList

public class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    
    // 用ReentrantLock实现线程安全
    final transient ReentrantLock lock = new ReentrantLock();
    
    // 没有size域，因为每次添加元素时，array都会改变，size和array的大小始终一致
    private transient volatile Object[] array;
    
    // 很简单，set(int index, E element)方法和add(E e)类似
    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            // 写时复制
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }
    
    final void setArray(Object[] a) {
        array = a;
    }
}

    迭代时，迭代器的数组只是一个快照，不是最新的。迭代器里定义了Object[] snapshot，初始化迭代器时snapshot = array。CopyOnWriteArraySet用CopyOnWriteArrayList实现，add()时调用CopyOnWriteArrayList的addIfAbsent()。

2、ArrayBlockingQueue和LinkedBlockingQueue

    BlockingQueue的添加操作有【1】add(E)，队列满时会抛异常【2】offer(E)，offer(E，long， TimeUnit)，等待一段时间，队列有空间就放入，一直满就返回false【3】put(E)队满会阻塞；取出操作有【1】poll(long，TimeUnit)一直无数据可取则返回null【2】remove()无数据则抛异常【3】take()无数据阻塞

    获取队头的操作有（BlockingQueue里没有定义这两个方法）【1】element()队列为空抛异常【2】peek()不抛异常

    （1）ArrayBlockingQueue，如下用循环队列和ReentrantLock实现，构造时可以指定大小和锁的公平性，默认用非公平锁。put()，take()时调用lockInterruptibly()，不满足条件则在Condition上等待。迭代时也会加锁。

public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable {
    final Object[] items;

    int takeIndex;

    int putIndex;

    int count;

    final ReentrantLock lock;

    private final Condition notEmpty;

    private final Condition notFull;

    // 可以指定大小和锁的公平性
    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();
    }

    private void enqueue(E x) {
        final Object[] items = this.items;
        items[putIndex] = x;
        // 循环队列
        if (++putIndex == items.length)
            putIndex = 0;
        count++;
        notEmpty.signal();
    }
        // 操作前后加锁解锁，take()类似
    public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == items.length)
                // 队列已满，在notFull上等待
                notFull.await();
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }
}

    （2）LinkedBlockingQueue，用两个ReentrantLock实现，可以同时put()，take()，引入了原子变量来计数。

public class LinkedBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable {

    private final int capacity;

    // 因为用了两个ReentrantLock，可以同时take()，put()，所以count必须是原子的
    private final AtomicInteger count = new AtomicInteger();

    transient Node<E> head;

    private transient Node<E> last;

    private final ReentrantLock takeLock = new ReentrantLock();

    private final Condition notEmpty = takeLock.newCondition();

    private final ReentrantLock putLock = new ReentrantLock();

    private final Condition notFull = putLock.newCondition();

    // 构造时也可以指定容量，不指定则默认Integer.MAX_VALUE
    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.capacity = capacity;
        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();
            }
            enqueue(node);
            c = count.getAndIncrement();
            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用两把？因为LinkedBlockingQueue需要构造节点（构造节点不在lock块里，应该主要是为了节省调整指针的时间）、调整指针，等待的时间比ArrayBlockingQueue（只需改变数组的相应位置，很快）长，用两把锁同时存取速度更快；而ArrayBlockingQueue如果用双锁，必须引入AtomicInteger，性能上几乎没有提升，代码更复杂了。

3、ConcurrentLinkedQueue

    head节点值为null，next指向第一个元素。插入时，tail.next ！= null时更新tail，tail可能是倒数第一或第二个节点。offer()时先定位尾节点，CAS将入队节点更新为尾节点的next节点，如果之前尾节点是倒数第二个节点，则更新尾节点。