首页 > 代码库 > 锁 和 CopyOnWrite的实现

锁 和 CopyOnWrite的实现

1.普通锁

只有lock功能, Java实现:ReentrantLock lock = new ReentrantLock();

  • lock和unlock:
lock.lock();
lock.unlock();

2.读写锁

读写锁:分为读锁和写锁,多个读锁不互斥,读锁与写锁互斥。

总之,读的时候上读锁,写的时候上写锁! Java里面的实现:ReentrantReadWriteLock

ReadWriteLock mylock = new ReentrantReadWriteLock(false);
  • 读锁lock、unlock:
myLock.readLock().lock();
myLock.readLock().unlock();
  • 写锁lock、unlock:
myLock.writeLock().lock();
myLock.writeLock().unlock();

3.总结

读写锁的本意是分别对读写状态进行互斥区分,有互斥时才加锁,否则放行.

互斥的情况有:

  1. 读写互斥.
  2. 写写互斥.

不互斥的情况是:读读,

读写锁使用更加高效,尤其适用于读线程多于写线程的场景。

4.CopyOnWrite

  • 使用场景:并发少量的写,多个读(确实适合Kafka的应用场景)。
  • JDK源码有CopyOnWriteArrayList和 CopyOnWriteArraySet的实现
  • Kafka的CopyOnWriteMap是自己实现的,基于lock的;另外还有基于CAS实现的,比如com.sun.jersey.client.impl.CopyOnWriteHashMap,具体实现暂且不讨论。

CopyOnWriteArrayList的核心思想是利用高并发往往是读多写少的特性,对读操作不加锁,对写操作,先复制一份新的集合,在新的集合上面修改,然后将新集合赋值给旧的引用,并通过volatile 保证其可见性,当然写操作的锁是必不可少的了。

Kafka-0.10的队列RecordAccumulator使用了自实现的CopyOnWriteMap.关键点如下:

  • map声明: volatile
  • read操作不加锁
  • put操作加锁:synchronized

A simple read-optimized map implementation that synchronizes only writes and does a full copy on each modification

private volatile Map<K, V> map; // volatile
this.map = Collections.unmodifiableMap(map); // 不可变map

public V get(Object k) { // read操作不加锁
        return map.get(k);
    }
    
// put操作加锁,先复制,在put.
public synchronized V put(K k, V v) {
        Map<K, V> copy = new HashMap<K, V>(this.map);
        V prev = copy.put(k, v);
        this.map = Collections.unmodifiableMap(copy);
        return prev;
    }

5. CopyOnWriteArrayList - 写时复制

JDK里的CopyOnWriteArrayList,核心是任何时候,保障只有一个写者。因此,也是对读不加锁、对写进行加锁。

基本思路是,从共享同一个内容,当想要修改这个内容的时候,才会真正把内容Copy出去形成一个新的内容然后再改,这是一种延时懒惰策略。

  • 底层实现是数组Object[],声明:volatile
  • 加锁的方式是ReentrantLock
  • copy的方法是Arrays.copyOf

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

5.2 读不加锁

读的时候不需要加锁,如果读的时候有多个线程正在向 CopyOnWriteArrayList添加数据,读还是会读到旧的数据,因为写的时候不会锁住旧的 CopyOnWriteArrayList

public E get(int index) {
        return get(getArray(), index);
    }

很简单,只要了解了CopyOnWrite机制,我们可以实现各种CopyOnWrite容器,并且在不同的应用场景中使用。

5.3 CopyOnWrite的应用场景

CopyOnWrite并发容器用于读多写少的并发场景。比如白名单,黑名单,商品类目的访问和更新场景,假如我们有一个搜索网站,用户在这个网站的搜索框中,输入关键字搜索内容,但是某些关键字不允许被搜索。这些不能被搜索的关键字会被放在一个黑名单当中,黑名单每天晚上更新一次。当用户搜索时,会检查当前关键字在不在黑名单当中,如果在,则提示不能搜索。

注意
  1. 减少扩容开销。根据实际需要,初始化CopyOnWriteMap的大小,避免写时CopyOnWriteMap扩容的开销。
  2. 使用批量添加。因为每次添加,容器每次都会进行复制,所以减少添加次数,可以减少容器的复制次数。

5.4 缺点

  • 内存占用问题。因为CopyOnWrite的写时复制机制,所以在进行写操作的时候,内存里会同时驻扎两个对象的内存,旧的对象和新写入的对象。
  • 数据一致性问题。CopyOnWrite容器只能保证数据的最终一致性,不能保证数据的实时一致性。所以如果希望写入的的数据,马上能读到,请不要使用CopyOnWrite容器。
  • 从上面那点,我想到另外一个知识点:volatile保证的是实时一致性。对比来看,CopyOnWriteArrayList的底层结构未使用volatile关键字;CopyOnWriteMap使用了volatile,能够对map的引用保证实时一致性,可以理解成对数据也是实时一致性的。

锁 和 CopyOnWrite的实现