欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

并发容器详解之CopyOnWriteArrayList

程序员文章站 2023-12-03 11:07:22
文章目录1. 诞生的历史和原因2. 适用场景3. 读写规则4. 实现原理5. 缺点6. 源码分析1. 诞生的历史和原因代替Vector和SyschronizedList 就像 ConcurrentHashMap 代替了SyschronizedMap的原因一样Vector和SyschronizedList 锁的粒度太大,并发效率较低,并且迭代时无法编辑Copy-On-Write 并发容器还包括CopyOnWriteArraySet,用来代替同步 Set2. 适用场景读操作尽可能的快一些,...

1. 诞生的历史和原因

  • 代替Vector和SyschronizedList 就像 ConcurrentHashMap 代替了SyschronizedMap的原因一样
  • Vector和SyschronizedList 锁的粒度太大,并发效率较低,并且迭代时无法编辑
  • Copy-On-Write 并发容器还包括CopyOnWriteArraySet,用来代替同步 Set

2. 适用场景

  • 读操作尽可能的快一些,而写即使慢一些也没关系

3. 读写规则

  • 回顾读写锁:读读共享、其他都互斥,(写写互斥,读写互斥,写读互斥)
  • 读写锁规则的升级:读取是完全不用加锁的,并且更厉害的是写入也不会阻塞读取操作,只有写入写入才会同步等待

ArrayList

 public static void main(String[] args) {
        List list=new ArrayList();
        list.add("11");
        list.add("22");
        list.add("33");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(list);
            Object next = iterator.next();
            System.out.println(next);
            if(next.equals("11")){
                list.remove("22");
            }
            if(next.equals("33")){
                list.add("2222");
            }
        }
}

并发容器详解之CopyOnWriteArrayList
CopyOnWriteArrayList

public static void main(String[] args) {
        CopyOnWriteArrayList list = new CopyOnWriteArrayList();
        list.add("11");
        list.add("22");
        list.add("33");
        list.add("44");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(list);
            Object next = iterator.next();
            System.out.println(next);
            if (next.equals("11")) {
                list.remove("22");
            }
            if (next.equals("33")) {
                list.add("2222");
            }
        }


    }

并发容器详解之CopyOnWriteArrayList
通过案例我们可以发现 ArrayList 迭代修改的时候会 抛出异常 ,而CopyOnWriteArrayList 不会

4. 实现原理&源码分析

CopyOnWrite的含义

创建新副本、读写分离

不可变原理

迭代的时候

我们看下ArrayList 源码为什么会报错

@SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

点开方法,他会进行一个比较操作所以会出现异常


        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

我们看下 CopyOnWriteArrayList 源码

这是CopyOnWriteArrayList存放数据的地方,只能通过getArray获取
并且他会上锁,用的ReentrantLock


/** The lock protecting all mutators */
    final transient ReentrantLock lock = new ReentrantLock();
    
 /** The array, accessed only via getArray/setArray. */
    private transient volatile Object[] array;

初始化 :构造函数 新建个空的数组

/**
     * Sets the array.
     */
    final void setArray(Object[] a) {
        array = a;
    }

    /**
     * Creates an empty list.
     */
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

add 方法

 /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        //先拿到锁
        lock.lock();
        try {
        //获取初始化数组
            Object[] elements = getArray();
            //获取长度 //copy出一个新的数组
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            //将我们的参数添加到这个位置
            newElements[len] = e;
            //set方法添加至
            setArray(newElements);
            return true;
        } finally {
        //释放锁
            lock.unlock();
        }
    }

get方法

@SuppressWarnings("unchecked")
    private E get(Object[] a, int index) {
        return (E) a[index];
    }

    /**
     * {@inheritDoc}
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E get(int index) {
        return get(getArray(), index);
    }
 public boolean hasNext() {
            return cursor < snapshot.length;
        }

        public boolean hasPrevious() {
            return cursor > 0;
        }

        @SuppressWarnings("unchecked")
        public E next() {
        //判断 true 和  false 
        //逻辑简单了许多
            if (! hasNext())
                throw new NoSuchElementException();
            return (E) snapshot[cursor++];
        }

5. 缺点

  • 数据一致性问题 :CopyOnWrite只能保证数据最终一致性的问题,不能保证数据实时一致性,所以希望写入的数据马上能读到,不要使用CopyOnWrite
  • 内存占用问题:因为CopyOnWrite的写是复制机制,所以在写的操作,所以内存中会存在2个对象

本文地址:https://blog.csdn.net/qq_41977838/article/details/107051046