并发--常见并发容器

一 JDK 提供的并发容器总结

JDK 提供的这些容器大部分在 java.util.concurrent 包中。

• ConcurrentHashMap: 线程安全的 HashMap
• CopyOnWriteArrayList: 线程安全的 List，在读多写少的场合性能非常好。
• ConcurrentLinkedQueue: 高效的并发队列，使用链表实现。可以看做一个线程安全的 LinkedList，这是一个非阻塞队列，内部采用CAS。
• BlockingQueue: 这是一个接口，JDK 内部通过链表、数组等方式实现了这个接口。表示阻塞队列，非常适合用于作为数据共享的通道。
• ConcurrentSkipListMap: 跳表的实现。是一个 Map，使用跳表数据结构进行快速查找。

除此之外，还可以使用 Collections.synchronizedMap()方法来包装相应的集合。但这是通过使用一个全局的锁来同步不同线程间的并发访问，因此会带来不可忽视的性能问题。

二 ConcurrentHashMap

JDK1.7
采用了分段锁（Segment），每个分段锁维护着几个桶（HashEntry），每个 HashEntry 是一个链表结构的元素，多个线程可以同时访问不同分段锁上的桶，并发度就是 Segment 的个数，默认创建 16 个 Segment。

Segment 继承自 ReentrantLock。

static final class Segment<K,V> extends ReentrantLock implements Serializable {
...
	transient volatile HashEntry<K,V>[] table;
}

static final class HashEntry<K,V> {
       final int hash;
       final K key;
       volatile V value;
       volatile HashEntry<K,V> next;
}

JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。并且在链表过长时会转换为红黑树，synchronized只锁定当前链表或红黑二叉树的首节点，这样只要hash不冲突，就不会产生并发。

三、 CopyOnWriteArrayList：适合读多写少，对实时性要求不高

写操作在一个复制的数组上进行，读操作还是在原始数组中进行，读写分离，互不影响。

类中所有可变操作（add，set 等等）都是通过创建底层数组的新副本来实现的。当 List 需要被修改的时候，并不修改原有内容，而是对原有数据进行一次复制，将修改的内容写入副本，写操作需加锁，防止并发写入时导致写入数据丢失。写完之后，就将指向原来内存指针指向新的内存，原来的内存被回收。

 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();//释放锁
        }
    }

缺陷：

• 内存占用：在写操作时需要复制一个新的数组，使得内存占用为原来的两倍左右；
• 数据不一致：读操作不能读取实时性数据，因部分写操作数据还未同步到读数组中。

四、 ConcurrentLinkedQueue
Java 提供的线程安全的 Queue 可以分为阻塞队列和非阻塞队列，其中阻塞队列的典型例子是 BlockingQueue，非阻塞队列的典型例子是 ConcurrentLinkedQueue， 阻塞队列可以通过加锁来实现，非阻塞队列可以通过 CAS 操作实现。
ConcurrentLinkedQueue使用链表作为其数据结构， 主要使用 CAS 非阻塞算法来实现线程安全。如果对队列加锁的成本较高则适合用无锁的 ConcurrentLinkedQueue 来替代。

五、 BlockingQueue
BlockingQueue 是一个接口，继承自 Queue，所以其实现类也可以作为 Queue 的实现来使用，而 Queue 又继承自 Collection 接口。下面是 BlockingQueue 的相关实现类：

阻塞队列（BlockingQueue）被广泛使用在“生产者-消费者”问题中，其原因是 BlockingQueue 提供了可阻塞的插入和移除的方法，不接受 null 值的插入。

• void put(E e) : 将指定元素插入队列中，如果满了，阻塞等待；
• E take(): 检索并删除队列头，如果为空，阻塞等待。

5.1 ArrayBlockingQueue
有界队列实现类，底层采用数组来实现。一旦创建，容量不能改变。其并发控制采用一个 ReentrantLock 和相应的两个 Condition 来实现。
ArrayBlockingQueue 默认情况下不能保证线程访问队列的公平性。如需要,采用以下构造函数：

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

5.2 LinkedBlockingQueue
底层基于单向链表实现的阻塞队列，可无界队列也可有界队列，同样满足 FIFO 的特性，创建时如果未指定容量大小，则等于 Integer.MAX_VALUE，通过构造函数指定的大小为其队列最大容量（固定，不会自动扩容）。
采用两个ReentrantLock锁，两个 Condition：

• takeLock 和 notEmpty ：如果要获取（take）一个元素，需要获取 takeLock 锁，但是获取了锁还不够，如果队列此时为空，还需要队列不为空（notEmpty）这个条件（Condition）。
• putLock 需要和 notFull ：如果要插入（put）一个元素，需要获取 putLock 锁，但是获取了锁还不够，如果队列此时已满，还需要队列不是满的（notFull）这个条件（Condition）。

5.3 PriorityBlockingQueue
支持优先级的无界阻塞队列。默认情况下元素采用自然顺序进行排序，可在初始化时通过构造器参数 Comparator 来指定排序规则。并发控制采用的是 ReentrantLock，队列为无界队列，构造函数只能指定初始的队列大小，后面插入元素的时候，如果空间不够的话会自动扩容。
不可以插入 null 值，同时，插入队列的对象必须是可比较大小的（comparable），否则报 ClassCastException 异常。它的插入操作 put 方法不会 block，因为它是无界队列（take 方法在队列为空的时候会阻塞）。

5.4 LinkedTransferQueue
是一个由链表数据结构构成的无界阻塞队列。
transfer(E e) 如果当前有消费者线程，生产者线程直接将数据传递给消费者线程。若没有，则将数据插入到队尾，直到有消费者能够进行消费才能退出；实时处理。

5.5 SynchronousQueue
容量为0，每个插入操作必须等待另个线程进行相应的删除操作，直接交给消费者处理。
若调用add(E e): 报错
若调用put(E e): 阻塞，等待消费者。