五、Java 常见并发容器总结

1.ConcurrentHashMap

ConcurrentHashMap : 线程安全的 HashMap

1.1 Collections.synchronizedMap()

并发时使用它方法包装HashMap同步，这属于全局锁，性能低下。

1.2 ConcurrentHashMap，

读写操作都能保证很高的性能
（1）在进行读操作时(几乎)不需要加锁

（2）写操作时通过锁分段技术，只对所操作的段加锁，而不影响客户端对其他段的访问。

2.CopyOnWriteArrayList

** 线程安全的 List，在读多写少的场合性能非常好，远远好于 Vector。**

2.1 写完全不加锁，写写加锁

写入也不会堵塞读取操作，只有写入和写入之间需要进行同步等待

2.2 如何实现？

所有可变操作（add，set 等等）都是通过创建底层数组的新副本来实现的。

（1）当需要修改时，并不修改原来数据，而是复制一份副本并对副本修改

（2）修改完完后，副本替换原来的数据

2.3 读取和写入源码简单分析

2.3.1 读取

读取操作没有任何同步控制和锁操作，理由就是内部数组 array 不会发生修改，只会被另外一个 array 替换，因此可以保证数据安全。

   /** The array, accessed only via getArray/setArray. */
    private transient volatile Object[] array;
    public E get(int index) {
        return get(getArray(), index);
    }
    @SuppressWarnings("unchecked")
    private E get(Object[] a, int index) {
        return (E) a[index];
    }
    final Object[] getArray() {
        return array;
    }

2.3.2 写入

写入操作 add()方法在添加集合的时候加了锁，保证了同步，避免了多线程写的时候会 copy 出多个副本出来。

 /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#add})
     */
    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();//释放锁
        }
    }

3.ConcurrentLinkedQueue

高效的并发队列，使用链表实现。可以看做一个线程安全的 LinkedList，这是一个非阻塞队列。

（1）主要使用 CAS 非阻塞算法来实现线程安全

（2）适合在对性能要求相对较高，同时对队列的读写存在多个线程同时进行的场景，即如果对队列加锁的成本较高则适合使用无锁的 ConcurrentLinkedQueue 来替代。

4.BlockingQueue

** 这是一个接口，JDK 内部通过链表、数组等方式实现了这个接口。表示阻塞队列，非常适合用于作为数据共享的通道。**

4.1 应用于“生产者-消费者”，提供了可阻塞的插入和移除的方法。

（1）当队列容器已满，生产者线程会被阻塞，直到队列未满；

（2）当队列容器为空时，消费者线程会被阻塞，直至队列非空时为止。

4.2 常见实现类

4.2.1 ArrayBlockingQueue

（1）有界队列实现类，底层采用数组来实现。

（2）并发控制采用可重入锁 ReentrantLock ，读写都需要获取到锁才能进行操作

（3）队列容量满时放入元素队列操作将会阻塞;队列空时中取元素也同样会阻塞。

（4）默认非公平性队列

（5）可改成公平性队列，但会降低吞吐量，如下：

private static ArrayBlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(10,true);

4.2.2 LinkedBlockingQueue

（1）底层基于单向链表实现的阻塞队列，既可作为有界队列也可作为无界队列

（2）比ArrayBlockingQueue 具有更高的吞吐量

（3）创建时指定大小防止容量速增，降低内存消耗，否则容量为Integer.MAX_VALUE。

构造方法如下：

 /**
     *某种意义上的无界队列
     * Creates a {@code LinkedBlockingQueue} with a capacity of
     * {@link Integer#MAX_VALUE}.
     */
    public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }

    /**
     *有界队列
     * Creates a {@code LinkedBlockingQueue} with the given (fixed) capacity.
     *
     * @param capacity the capacity of this queue
     * @throws IllegalArgumentException if {@code capacity} is not greater
     *         than zero
     */
    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node<E>(null);
    }