代码理解java多线程 (三) - JDK工具篇（5）- 并发容器集合 & CopyOnWrite容器

目录

第十五章 并发容器集合

15.1 同步容器与并发容器

15.2 并发容器类介绍

15.2.1 并发Map

15.2.2 并发Queue

15.2.3 并发Set

第十六章 CopyOnWrite容器

16.1 什么是CopyOnWrite容器

16.2 CopyOnWriteArrayList

16.3 CopyOnWrite的业务中实现

---

第十五章 并发容器集合

15.1 同步容器与并发容器

我们知道在java.util包下提供了一些容器类，而Vector和HashTable是线程安全的容器类，但是这些容器实现同步的方式是通过对方法加锁(sychronized)方式实现的，这样读写均需要锁操作，导致性能低下。

而即使是Vector这样线程安全的类，在面对多线程下的复合操作的时候也是需要通过客户端加锁的方式保证原子性。如下面例子说明:

1. public class TestVector {
2. private Vector<String> vector;
3.  
4. //方法一
5. public Object getLast(Vector vector) {
6. int lastIndex = vector.size() - 1;
7. return vector.get(lastIndex);
8. }
9.  
10. //方法二
11. public void deleteLast(Vector vector) {
12. int lastIndex = vector.size() - 1;
13. vector.remove(lastIndex);
14. }
15.  
16. //方法三
17. public Object getLastSysnchronized(Vector vector) {
18. synchronized(vector){
19. int lastIndex = vector.size() - 1;
20. return vector.get(lastIndex);
21. }
22. }
23.  
24. //方法四
25. public void deleteLastSysnchronized(Vector vector) {
26. synchronized (vector){
27. int lastIndex = vector.size() - 1;
28. vector.remove(lastIndex);
29. }
30. }
31.  
32. }

如果方法一和方法二为一个组合的话。那么当方法一获取到了vector的size之后，方法二已经执行完毕，这样就导致程序的错误。

如果方法三与方法四组合的话。通过锁机制保证了在vector上的操作的原子性。

并发容器是Java 5 提供的在多线程编程下用于代替同步容器，针对不同的应用场景进行设计，提高容器的并发访问性，同时定义了线程安全的复合操作。

15.2 并发容器类介绍

整体架构(列举常用的容器类)

其中，阻塞队列（BlockingQueue）在第十三章有介绍，CopyOnWrite容器（CopyOnWritexxx）在第十六章有介绍，这里不做过多介绍。

下面分别介绍一些常用的并发容器类和接口，因篇幅原因，这里只介绍这些类的用途和基本的原理，不做过多的源码解析。

15.2.1 并发Map

ConcurrentMap接口

ConcurrentMap接口继承了Map接口，在Map接口的基础上又定义了四个方法：

1. public interface ConcurrentMap<K, V> extends Map<K, V> {
2.  
3. //插入元素
4. V putIfAbsent(K key, V value);
5.  
6. //移除元素
7. boolean remove(Object key, Object value);
8.  
9. //替换元素
10. boolean replace(K key, V oldValue, V newValue);
11.  
12. //替换元素
13. V replace(K key, V value);
14.  
15. }

putIfAbsent：与原有put方法不同的是，putIfAbsent方法中如果插入的key相同，则不替换原有的value值；

remove：与原有remove方法不同的是，新remove方法中增加了对value的判断，如果要删除的key-value不能与Map中原有的key-value对应上，则不会删除该元素;

replace(K,V,V)：增加了对value值的判断，如果key-oldValue能与Map中原有的key-value对应上，才进行替换操作；

replace(K,V)：与上面的replace不同的是，此replace不会对Map中原有的key-value进行比较，如果key存在则直接替换；

ConcurrentHashMap类

ConcurrentHashMap同HashMap一样也是基于散列表的map，但是它提供了一种与HashTable完全不同的加锁策略提供更高效的并发性和伸缩性。

ConcurrentHashMap提供了一种粒度更细的加锁机制来实现在多线程下更高的性能，这种机制叫分段锁(Lock Striping)。

提供的优点是：在并发环境下将实现更高的吞吐量，而在单线程环境下只损失非常小的性能。

可以这样理解分段锁，就是将数据分段，对每一段数据分配一把锁。当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。

有些方法需要跨段，比如size()、isEmpty()、containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁。如下图：

ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment是一种可重入锁ReentrantLock，HashEntry则用于存储键值对数据。

一个ConcurrentHashMap里包含一个Segment数组，Segment的结构和HashMap类似，是一种数组和链表结构， 一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构（同HashMap一样，它也会在长度达到8的时候转化为红黑树）的元素， 每个Segment守护者一个HashEntry数组里的元素，当对HashEntry数组的数据进行修改时，必须首先获得它对应的Segment锁。

ConcurrentNavigableMap接口与ConcurrentSkipListMap类

ConcurrentNavigableMap接口继承了NavigableMap接口，这个接口提供了针对给定搜索目标返回最接近匹配项的导航方法。

ConcurrentNavigableMap接口的主要实现类是ConcurrentSkipListMap类。从名字上来看，它的底层使用的是跳表（SkipList）的数据结构。关于跳表的数据结构这里不做太多介绍，它是一种”空间换时间“的数据结构，可以使用CAS来保证并发安全性。

15.2.2 并发Queue

JDK并没有提供线程安全的List类，因为对List来说，很难去开发一个通用并且没有并发瓶颈的线程安全的List。因为即使简单的读操作，拿contains() 这样一个操作来说，很难搜索的时候如何避免锁住整个list。

所以退一步，JDK提供了对队列和双端队列的线程安全的类：ConcurrentLinkedDeque和ConcurrentLinkedQueue。因为队列相对于List来说，有更多的限制。这两个类是使用CAS来实现线程安全的。

15.2.3 并发Set

JDK提供了ConcurrentSkipListSet，是线程安全的有序的集合。底层是使用ConcurrentSkipListMap实现。

谷歌的guava框架实现了一个线程安全的ConcurrentHashSet：

 复制代码

1. Set<String> s = Sets.newConcurrentHashSet();

 

第十六章 CopyOnWrite容器

16.1 什么是CopyOnWrite容器

在说到CopyOnWrite容器之前我们先来谈谈什么是CopyOnWrite机制，CopyOnWrite是计算机设计领域中的一种优化策略，也是一种在并发场景下常用的设计思想——写入时复制思想。

那什么是写入时复制思想呢？就是当有多个调用者同时去请求一个资源数据的时候，有一个调用者出于某些原因需要对当前的数据源进行修改，这个时候系统将会复制一个当前数据源的副本给调用者修改。

CopyOnWrite容器即写时复制的容器,当我们往一个容器中添加元素的时候，不直接往容器中添加，而是将当前容器进行copy，复制出来一个新的容器，然后向新容器中添加我们需要的元素，最后将原容器的引用指向新容器。

这样做的好处在于，我们可以在并发的场景下对容器进行”读操作”而不需要”加锁”，从而达到读写分离的目的。从JDK 1.5 开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器 ，分别是CopyOnWriteArrayList和CopyOnWriteArraySet 。我们着重给大家介绍一下CopyOnWriteArrayList。

16.2 CopyOnWriteArrayList

优点：
CopyOnWriteArrayList经常被用于“读多写少”的并发场景，是因为CopyOnWriteArrayList无需任何同步措施，大大增强了读的性能。在Java中遍历线程非安全的List(如：ArrayList和 LinkedList)的时候，若中途有别的线程对List容器进行修改，那么会抛出ConcurrentModificationException异常。CopyOnWriteArrayList由于其”读写分离”，遍历和修改操作分别作用在不同的List容器，所以在使用迭代器遍历的时候，则不会抛出异常。

缺点：
第一个缺点是CopyOnWriteArrayList每次执行写操作都会将原容器进行拷贝了一份，数据量大的时候，内存会存在较大的压力，可能会引起频繁Full GC（ZGC因为没有使用Full GC）。比如这些对象占用的内存比较大200M左右，那么再写入100M数据进去，内存就会多占用300M。

第二个缺点是CopyOnWriteArrayList由于实现的原因，写和读分别作用在不同新老容器上，在写操作执行过程中，读不会阻塞，但读取到的却是老容器的数据。

现在我们来看一下CopyOnWriteArrayList的add操作源码，它的逻辑很清晰，就是先把原容器进行copy，然后在新的副本上进行“写操作”，最后再切换引用，在此过程中是加了锁的。

1. public boolean add(E e) {
2.  
3. // ReentrantLock加锁，保证线程安全
4. final ReentrantLock lock = this.lock;
5. lock.lock();
6. try {
7. Object[] elements = getArray();
8. int len = elements.length;
9. // 拷贝原容器，长度为原容器长度加一
10. Object[] newElements = Arrays.copyOf(elements, len + 1);
11. // 在新副本上执行添加操作
12. newElements[len] = e;
13. // 将原容器引用指向新副本
14. setArray(newElements);
15. return true;
16. } finally {
17. // 解锁
18. lock.unlock();
19. }
20. }

我们再来看一下remove操作的源码，remove的逻辑是将要remove元素之外的其他元素拷贝到新的副本中，然后切换引用，再将原容器的引用指向新的副本中，因为remove操作也是“写操作”所以也是要加锁的。

1. public E remove(int index) {
2.  
3. // 加锁
4. final ReentrantLock lock = this.lock;
5. lock.lock();
6. try {
7. Object[] elements = getArray();
8. int len = elements.length;
9. E oldValue = get(elements, index);
10. int numMoved = len - index - 1;
11. if (numMoved == 0)
12. // 如果要删除的是列表末端数据，拷贝前len-1个数据到新副本上，再切换引用
13. setArray(Arrays.copyOf(elements, len - 1));
14. else {
15. // 否则，将除要删除元素之外的其他元素拷贝到新副本中，并切换引用
16. Object[] newElements = new Object[len - 1];
17. System.arraycopy(elements, 0, newElements, 0, index);
18. System.arraycopy(elements, index + 1, newElements, index,
19. numMoved);
20. setArray(newElements);
21. }
22. return oldValue;
23. } finally {
24. // 解锁
25. lock.unlock();
26. }
27. }

我们再来看看CopyOnWriteArrayList效率最高的读操作的源码

1. public E get(int index) {
2. return get(getArray(), index);
3. }

1. private E get(Object[] a, int index) {
2. return (E) a[index];
3. }

由上可见“读操作”是没有加锁，直接读取。

16.3 CopyOnWrite的业务中实现

接下来，我们来具体结合业务场景实现一个CopyOnWriteMap的并发容器并且来使用它。

1. import java.util.Collection;
2. import java.util.Map;
3. import java.util.Set;
4.  
5. public class CopyOnWriteMap<K, V> implements Map<K, V>, Cloneable {
6. private volatile Map<K, V> internalMap;
7.  
8. public CopyOnWriteMap() {
9. internalMap = new HashMap<K, V>();
10. }
11.  
12. public V put(K key, V value) {
13. synchronized (this) {
14. Map<K, V> newMap = new HashMap<K, V>(internalMap);
15. V val = newMap.put(key, value);
16. internalMap = newMap;
17. return val;
18. }
19. }
20.  
21. public V get(Object key) {
22. return internalMap.get(key);
23. }
24.  
25. public void putAll(Map<? extends K, ? extends V> newData) {
26. synchronized (this) {
27. Map<K, V> newMap = new HashMap<K, V>(internalMap);
28. newMap.putAll(newData);
29. internalMap = newMap;
30. }
31. }
32. }

上面就是参考CopyOnWriteArrayList实现的CopyOnWriteMap，我们可以用这个容器来做什么呢？结合我们之前说的CopyOnWrite的复制思想，它最适用于“读多写少”的并发场景。

场景：假如我们有一个搜索的网站需要屏蔽一些“关键字”，“黑名单”每晚定时更新，每当用户搜索的时候，“黑名单”中的关键字不会出现在搜索结果当中，并且提示用户敏感字。

1. // 黑名单服务
2. public class BlackListServiceImpl {
3. //　减少扩容开销。根据实际需要，初始化CopyOnWriteMap的大小，避免写时CopyOnWriteMap扩容的开销。
4. private static CopyOnWriteMap<String, Boolean> blackListMap =
5. new CopyOnWriteMap<String, Boolean>(1000);
6.  
7. public static boolean isBlackList(String id) {
8. return blackListMap.get(id) == null ? false : true;
9. }
10.  
11. public static void addBlackList(String id) {
12. blackListMap.put(id, Boolean.TRUE);
13. }
14.  
15. /**
16. * 批量添加黑名单
17. * (使用批量添加。因为每次添加，容器每次都会进行复制，所以减少添加次数，可以减少容器的复制次数。
18. * 如使用上面代码里的addBlackList方法)
19. * @param ids
20. */
21. public static void addBlackList(Map<String,Boolean> ids) {
22. blackListMap.putAll(ids);
23. }
24.  
25. }

这里需要各位小伙伴特别特别注意一个问题，此处的场景是每晚凌晨“黑名单”定时更新，原因是CopyOnWrite容器有数据一致性的问题，它只能保证最终数据一致性。

所以如果我们希望写入的数据马上能准确地读取，请不要使用CopyOnWrite容器。