锁 和 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的引用保证实时一致性,可以理解成对数据也是实时一致性的。

时间: 2024-10-10 06:58:55

锁 和 CopyOnWrite的实现的相关文章

Copy-On-Write容器

Copy-On-write简称COW,是一种用于程序设计中的优化策略. JDK里的COW容器有两种:CopyOnWriteArrayList和CopyOnWriteArraySet,COW容器非常有用,可以在非常多的并发场景中使用到. CopyOnWrite容器即写时复制的容器.通俗的理解是当我们往一个容器添加元素的时候,不直接往当前容器添加,而是先将当前容器进行Copy,复制出一个新的容器. 这样做的好处是我们可以对CopyOnWrite容器进行并发的读,而不需要加锁,因为当前容器不会添加任何

Java并发(6):concurrent包中的Copy-On-Write容器

Copy-On-Write简称COW,是一种用于程序设计中的优化策略.其基本思路是,从一开始大家都在共享同一个内容,当某个人想要修改这个内容的时候,才会真正把内容Copy出去形成一个新的内容然后再改,这是一种延时懒惰策略.从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器,它们是CopyOnWriteArrayList和CopyOnWriteArraySet.CopyOnWrite容器非常有用,可以在非常多的并发场景中使用到. 一. CopyOnWrite容

并发-Java中的Copy-On-Write容器

Copy-On-Write简称COW,是一种用于程序设计中的优化策略.其基本思路是,从一开始大家都在共享同一个内容,当某个人想要修改这个内容的时候,才会真正把内容Copy出去形成一个新的内容然后再改,这是一种延时懒惰策略.从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器,它们是CopyOnWriteArrayList和CopyOnWriteArraySet.CopyOnWrite容器非常有用,可以在非常多的并发场景中使用到. 什么是CopyOnWrite容

构建高性能服务(二)java高并发锁的3种实现

构建高性能服务(二)java高并发锁的3种实现 来源:http://www.xymyeah.com/?p=46 提高系统并发吞吐能力是构建高性能服务的重点和难点.通常review代码时看到synchronized是我都会想一想,这个地方可不可以优化.使用synchronized使得并发的线程变成顺序执行,对系统并发吞吐能力有极大影响,我的博文 http://maoyidao.iteye.com/blog/1149015 介绍了可以从理论上估算系统并发处理能力的方法. 那么对于必须使用synchr

JAVA中写时复制(Copy-On-Write)Map实现

1,什么是写时复制(Copy-On-Write)容器? 写时复制是指:在并发访问的情景下,当需要修改JAVA中Containers的元素时,不直接修改该容器,而是先复制一份副本,在副本上进行修改.修改完成之后,将指向原来容器的引用指向新的容器(副本容器). 2,写时复制带来的影响 ①由于不会修改原始容器,只修改副本容器.因此,可以对原始容器进行并发地读.其次,实现了读操作与写操作的分离,读操作发生在原始容器上,写操作发生在副本容器上. ②数据一致性问题:读操作的线程可能不会立即读取到新修改的数据

ConcurrentMap与CopyOnWrite容器

ConcurrentMap接口下有两个重要的实现: ConcurrentHashMap ConcurrentSkipListMap(支持并发排序功能,弥补ConcurrentHashMap) ConcurrentHashMap内部使用段(Segment)来表示这些不同的部分,每个段其实就是一个小的HashTable,它们有自己的锁.只要多个修改操作发生在不同的段上,他们就可以并发进行.把一个整体分成了16个小段(Segment).也就是最高支持16个线程的并发修改操作.这也是在多线程场景时减小锁

java高并发锁的3种实现

初级技巧 - 乐观锁 乐观锁适合这样的场景:读不会冲突,写会冲突.同时读的频率远大于写. 以下面的代码为例,悲观锁的实现: Java代码   public Object get(Object key) { synchronized(map) { if(map.get(key) == null) { // set some values } return map.get(key); } } 乐观锁的实现: Java代码   public Object get(Object key) { Objec

Java:Copy-On-Write容器

Copy-On-Write简称COW,是一种用于程序设计中的优化策略.其基本思路是,从一开始大家都在共享同一个内容,当某个人想要修改这个内容的时候,才会真正把内容Copy出去形成一个新的内容然后再改,这是一种延时懒惰策略.从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器,它们是CopyOnWriteArrayList和CopyOnWriteArraySet.CopyOnWrite容器非常有用,可以在非常多的并发场景中使用到. 什么是CopyOnWrite容

什么是CopyOnWrite

前段时间写过一篇关于concurrentHashMap的文章ConcurrentHashMap实现原理,其中讲到了实现ConcurrentHashMap的原理,这篇文章就讲一下CopyOnWrite的实现原理.Java中提供了两个CopyOnWrite容器,分别是CopyOnWriteArrayList和CopyOnWriteArraySet.如果想要高效的使用这两个容器,我觉的首先要弄懂CopyOnWrite的原理.那么下面就先来谈谈什么是CopyOnWrite吧. 什么是CopyOnWrit