Java 并发编程——CopyOnWriteArrayList

1 简述

CopyOnWriteArrayList 是从 JDK5 开始引进的并发集合之一，另一个是 CopyOnWriteArraySet，JDK 并没有提供 Map 的实现，我们之后将实现它。

2 COW

Copy-On-Write简称COW，是一种用于程序设计中的优化策略。思路是，从一开始大家都在共享同一个内容，当某个人想要修改这个内容的时候，才会真正把内容Copy出去形成一个新的内容然后再改，这是一种延时懒惰策略。这种策略使得我们可以并发的读，而不用获取全局锁（但是写则需要获取锁）。体现的是读写分离的思想。但是因为每次添加都会复制原有的数组内容，因此存在内存开销问题。相对的，其他 Concurrent* 类的读写都会获取锁。

2.1 add 源码分析

    // 使用 volatile 类型，只通过   getArray/setArray 访问
    private transient volatile Object[] array;

   @Override
    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();
        }
    }

2.2 get 源码分析

    public E get(int index) {
        // 获取现数组，不需要加锁，所以可能会获取到旧的数据（当存在另一个线程对 List 进行写操作是）
        return get(getArray(), index);
    }

根据 2.1 ，这个方法获取到的数组可能会是旧的。

3 实现 CopyOnWriteMap 

遵循上边的设计，我们可以围绕 COW 设计出 Map

package cn.pancc.purejdk.concurrent.fenxi;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author pancc
 * @version 1.0
 */
public class CopyOnWriteMap<K, V> implements Map<K, V>, Cloneable, java.io.Serializable {
    private static final long serialVersionUID = -6907385757412808108L;
    private volatile Map<K, V> map = new HashMap<>();

    public Map<K, V> getMap() {
        return map;
    }

    public void setMap(Map<K, V> map) {
        this.map = map;
    }

    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public int size() {
        return getMap().size();
    }

    @Override
    public boolean isEmpty() {
        return getMap().isEmpty();
    }

    @Override
    public boolean containsKey(Object key) {
        return getMap().containsKey(key);
    }

    @Override
    public boolean containsValue(Object value) {
        return getMap().containsValue(value);
    }

    @Override
    public V get(Object key) {
        return getMap().get(key);
    }

    @Override
    public V put(K key, V value) {
        lock.lock();
        try {
            Map<K, V> newMap = new HashMap<>(map);
            V v = newMap.put(key, value);
            this.map = newMap;
            return v;
        } finally {
            lock.unlock();
        }
    }

    @Override
    public V remove(Object key) {
        lock.lock();
        try {
            Map<K, V> newMap = new HashMap<>(map);
            V v = newMap.remove(key);
            this.map = newMap;
            return v;
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        lock.lock();
        try {
            Map<K, V> newMap = new HashMap<>(map);
            newMap.putAll(m);
            this.map = newMap;
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void clear() {
        lock.lock();
        try {
            this.map = new HashMap<>();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public Set<K> keySet() {
        return getMap().keySet();
    }

    @Override
    public Collection<V> values() {
        return getMap().values();
    }

    @Override
    public Set<Entry<K, V>> entrySet() {
        return getMap().entrySet();
    }
}

4 COW 的缺点

• 内存占用问题：每次写操作都会执行复制操作
• 数据一致性问题：写操作并不会及时影响到读操作获取的数据

5 应用场景

适用于读多写少的场景，如黑名单机制，单位信息缓存