java并发(二十一)——CopyOnWriteArrayList和CopyOnWriteArraySet

最新推荐文章于 2022-03-22 11:51:00 发布

微笑看你哭

最新推荐文章于 2022-03-22 11:51:00 发布

阅读量348

点赞数

分类专栏： java 并发

java 并发专栏收录该内容

24 篇文章 0 订阅

订阅专栏

CopyOnWriteArrayList

CopyOnWriteArrayList容器是Collections.synchronizedList(List list)的替代方案，CopyOnWriteArrayList在某些情况下具有更好的性能，考虑读远大于写的场景，如果把所有的读操作进行加锁，因为只有一个读线程能够获得锁，所以其他的读线程都必须等待，大大影响性能。CopyOnWriteArrayList称为“写时复制”容器，就是在多线程操作容器对象时，把容器复制一份，这样在线程内部的修改就与其他线程无关了，而且这样设计可以做到不阻塞其他的读线程。

CopyOnWriteArrayList数据结构

通过源码分析可知，CopyOnWriteArrayList使用的数据结构是数组。结构如下
在这里插入图片描述
说明：CopyOnWriteArrayList底层使用数组来存放元素。

类的继承关系

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}

说明：CopyOnWriteArrayList实现了List接口，List接口定义了对列表的基本操作；同时实现了RandomAccess接口，表示可以随机访问（数组具有随机访问的特性）；同时实现了Cloneable接口，表示可克隆；同时也实现了Serializable接口，表示可被序列化。

类的内部类

COWIterator类

static final class COWIterator<E> implements ListIterator<E> {
        /** Snapshot of the array */
        // 快照
        private final Object[] snapshot;
        /** Index of element to be returned by subsequent call to next.  */
        // 游标
        private int cursor;
        // 构造函数
        private COWIterator(Object[] elements, int initialCursor) {
            cursor = initialCursor;
            snapshot = elements;
        }
        // 是否还有下一项
        public boolean hasNext() {
            return cursor < snapshot.length;
        }
        // 是否有上一项
        public boolean hasPrevious() {
            return cursor > 0;
        }
        // next项
        @SuppressWarnings("unchecked")
        public E next() {
            if (! hasNext()) // 不存在下一项，抛出异常
                throw new NoSuchElementException();
            // 返回下一项
            return (E) snapshot[cursor++];
        }

        @SuppressWarnings("unchecked")
        public E previous() {
            if (! hasPrevious())
                throw new NoSuchElementException();
            return (E) snapshot[--cursor];
        }
        
        // 下一项索引
        public int nextIndex() {
            return cursor;
        }
        
        // 上一项索引
        public int previousIndex() {
            return cursor-1;
        }

        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @throws UnsupportedOperationException always; {@code remove}
         *         is not supported by this iterator.
         */
        // 不支持remove操作
        public void remove() {
            throw new UnsupportedOperationException();
        }

        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @throws UnsupportedOperationException always; {@code set}
         *         is not supported by this iterator.
         */
        // 不支持set操作
        public void set(E e) {
            throw new UnsupportedOperationException();
        }

        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @throws UnsupportedOperationException always; {@code add}
         *         is not supported by this iterator.
         */
        // 不支持add操作
        public void add(E e) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            Object[] elements = snapshot;
            final int size = elements.length;
            for (int i = cursor; i < size; i++) {
                @SuppressWarnings("unchecked") E e = (E) elements[i];
                action.accept(e);
            }
            cursor = size;
        }
    }

说明：COWIterator表示迭代器，其也有一个Object类型的数组作为CopyOnWriteArrayList数组的快照，这种快照风格的迭代器方法在创建迭代器时使用了对当时数组状态的引用。此数组在迭代器的生存期内不会更改，因此不可能发生冲突，并且迭代器保证不会抛出 ConcurrentModificationException。创建迭代器以后，迭代器就不会反映列表的添加、移除或者更改。在迭代器上进行的元素更改操作（remove、set 和 add）不受支持。这些方法将抛出 UnsupportedOperationException。

类的属性

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    // 版本序列号
    private static final long serialVersionUID = 8673264195747942595L;
    // 可重入锁
    final transient ReentrantLock lock = new ReentrantLock();
    // 对象数组，用于存放元素
    private transient volatile Object[] array;
    // 反射机制
    private static final sun.misc.Unsafe UNSAFE;
    // lock域的内存偏移量
    private static final long lockOffset;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> k = CopyOnWriteArrayList.class;
            lockOffset = UNSAFE.objectFieldOffset
                (k.getDeclaredField("lock"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }
}

说明：属性中有一个可重入锁，用来保证线程安全访问，还有一个Object类型的数组，用来存放具体的元素。当然，也使用到了反射机制和CAS来保证原子性的修改lock域。

类的构造函数

CopyOnWriteArrayList()型构造函数

	public CopyOnWriteArrayList() {
        // 设置数组
        setArray(new Object[0]);
    }

说明：该构造函数用于创建一个空列表。

CopyOnWriteArrayList(Collection<? extends E>)型构造函数

    public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements;
        if (c.getClass() == CopyOnWriteArrayList.class) // 类型相同
            // 获取c集合的数组
            elements = ((CopyOnWriteArrayList<?>)c).getArray();
        else { // 类型不相同
            // 将c集合转化为数组并赋值给elements
            elements = c.toArray();
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elements.getClass() != Object[].class) // elements类型不为Object[]类型
                // 将elements数组转化为Object[]类型的数组
                elements = Arrays.copyOf(elements, elements.length, Object[].class);
        }
        // 设置数组
        setArray(elements);
    }

说明：该构造函数用于创建一个按 collection 的迭代器返回元素的顺序包含指定 collection 元素的列表。该构造函数的处理流程如下：

判断传入的集合c的类型是否为CopyOnWriteArrayList类型，若是，则获取该集合类型的底层数组（Object[]），并且设置当前CopyOnWriteArrayList的数组（Object[]数组），进入步骤③；否则，进入步骤②
将传入的集合转化为数组elements，判断elements的类型是否为Object[]类型（toArray方法可能不会返回Object类型的数组），若不是，则将elements转化为Object类型的数组。进入步骤③
设置当前CopyOnWriteArrayList的Object[]为elements。

CopyOnWriteArrayList(E[])型构造函数

    public CopyOnWriteArrayList(E[] toCopyIn) {
        // 将toCopyIn转化为Object[]类型数组，然后设置当前数组
        setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
    }

说明：该构造函数用于创建一个保存给定数组的副本的列表。

核心函数分析

对于CopyOnWriteArrayList的函数分析，主要明白Arrays.copyOf方法即可理解CopyOnWriteArrayList其他函数的意义。

copyOf函数

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        // 确定copy的类型（将newType转化为Object类型，将Object[].class转化为Object类型，判断两者是否相等，若相等，则生成指定长度的Object数组
        // 否则,生成指定长度的新类型的数组）
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        // 将original数组从下标0开始，复制长度为(original.length和newLength的较小者),复制到copy数组中（也从下标0开始）
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

说明：该函数用于复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。

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);
            // 存放元素e
            newElements[len] = e;
            // 设置数组
            setArray(newElements);
            return true;
        } finally {
            // 释放锁
            lock.unlock();
        }
    }

说明：此函数用于将指定元素添加到此列表的尾部，处理流程如下：

获取锁（保证多线程的安全访问），获取当前的Object数组，获取Object数组的长度为length，进入步骤②。
根据Object数组复制一个长度为length+1的Object数组为newElements（此时，newElements[length]为null），进入步骤③。
将下标为length的数组元素newElements[length]设置为元素e，再设置当前Object[]为newElements，释放锁，返回。这样就完成了元素的添加。

可以发现在添加的时候是需要加锁的，否则多线程写的时候会Copy出N个

addIfAbsent

    private boolean addIfAbsent(E e, Object[] snapshot) {
        // 重入锁
        final ReentrantLock lock = this.lock;
        // 获取锁
        lock.lock();
        try {
            // 获取数组
            Object[] current = getArray();
            // 数组长度
            int len = current.length;
            if (snapshot != current) { // 快照不等于当前数组，对数组进行了修改
                // Optimize for lost race to another addXXX operation
                // 取较小者
                int common = Math.min(snapshot.length, len);
                for (int i = 0; i < common; i++) // 遍历
                    if (current[i] != snapshot[i] && eq(e, current[i])) // 当前数组的元素与快照的元素不相等并且e与当前元素相等
                        // 表示在snapshot与current之间修改了数组，并且设置了数组某一元素为e，已经存在
                        // 返回
                        return false;
                if (indexOf(e, current, common, len) >= 0) // 在当前数组中找到e元素
                        // 返回
                        return false;
            }
            // 复制数组
            Object[] newElements = Arrays.copyOf(current, len + 1);
            // 对数组len索引的元素赋值为e
            newElements[len] = e;
            // 设置数组
            setArray(newElements);
            return true;
        } finally {
            // 释放锁
            lock.unlock();
        }
    }

说明：该函数用于添加元素（如果数组中不存在，则添加；否则，不添加，直接返回）。可以保证多线程环境下不会重复添加元素，该函数的流程如下:

获取锁，获取当前数组为current，current长度为len，判断数组之前的快照snapshot是否等于当前数组current，若不相等，则进入步骤②；否则，进入步骤④
不相等，表示在snapshot与current之间，对数组进行了修改（如进行了add、set、remove等操作），获取长度（snapshot与current之间的较小者），对current进行遍历操作，若遍历过程发现snapshot与current的元素不相等并且current的元素与指定元素相等（可能进行了set操作），进入步骤⑤，否则，进入步骤③
在当前数组中索引指定元素，若能够找到，进入步骤⑤，否则，进入步骤④
复制当前数组current为newElements，长度为len+1，此时newElements[len]为null。再设置newElements[len]为指定元素e，再设置数组，进入步骤⑤
释放锁，返回。

set函数

    public E set(int index, E element) {
        // 可重入锁
        final ReentrantLock lock = this.lock;
        // 获取锁
        lock.lock();
        try {
            // 获取数组
            Object[] elements = getArray();
            // 获取index索引的元素
            E oldValue = get(elements, index);

            if (oldValue != element) { // 旧值等于element
                // 数组长度
                int len = elements.length;
                // 复制数组
                Object[] newElements = Arrays.copyOf(elements, len);
                // 重新赋值index索引的值
                newElements[index] = element;
                // 设置数组
                setArray(newElements);
            } else {
                // Not quite a no-op; ensures volatile write semantics
                // 设置数组
                setArray(elements);
            }
            // 返回旧值
            return oldValue;
        } finally {
            // 释放锁
            lock.unlock();
        }
    }

说明：此函数用于用指定的元素替代此列表指定位置上的元素，也是基于数组的复制来实现的。

remove函数

    public E remove(int index) {
        // 可重入锁
        final ReentrantLock lock = this.lock;
        // 获取锁
        lock.lock();
        try {
            // 获取数组
            Object[] elements = getArray();
            // 数组长度
            int len = elements.length;
            // 获取旧值
            E oldValue = get(elements, index);
            // 需要移动的元素个数
            int numMoved = len - index - 1;
            if (numMoved == 0) // 移动个数为0
                // 复制后设置数组
                setArray(Arrays.copyOf(elements, len - 1));
            else { // 移动个数不为0
                // 新生数组
                Object[] newElements = new Object[len - 1];
                // 复制index索引之前的元素
                System.arraycopy(elements, 0, newElements, 0, index);
                // 复制index索引之后的元素
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);
                // 设置索引
                setArray(newElements);
            }
            // 返回旧值
            return oldValue;
        } finally {
            // 释放锁
            lock.unlock();
        }
    }

说明：此函数用于移除此列表指定位置上的元素。处理流程如下：

获取锁，获取数组elements，数组长度为length，获取索引的值elements[index]，计算需要移动的元素个数（length - index - 1）,若个数为0，则表示移除的是数组的最后一个元素，复制elements数组，复制长度为length-1，然后设置数组，进入步骤③；否则，进入步骤②
先复制index索引前的元素，再复制index索引后的元素，然后设置数组。
释放锁，返回旧值。

CopyOnWriteArraySet

分析完了CopyOnWriteArrayList后，下面接着分析CopyOnWriteArraySet，CopyOnWriteArraySet与CopyOnWriteArrayList有莫大的联系，因为CopyOnWriteArraySet的底层是由CopyOnWriteArrayList提供支持，并且将对其的操作转发至对CopyOnWriteArrayList的操作。但是，CopyOnWriteArraySet的元素不允许重复，这是和CopyOnWriteArrayList不相同的地方，下面开始分析。

CopyOnWriteArraySet数据结构

由于CopyOnWriteArraySet底层是使用CopyOnWriteArrayList，所以其数据结构与CopyOnWriteArrayList相同，采用数组结构。其结构如下
在这里插入图片描述
说明：CopyOnWriteArraySet由于是基于CopyOnWriteArrayList的，所以对其操作都是基于CopyOnWriteArrayList的，其中所有可变操作（add、set 等等）都是通过对底层数组进行一次新的复制来实现的。

类的继承关系

public class CopyOnWriteArraySet<E> extends AbstractSet<E>
        implements java.io.Serializable {}

说明：CopyOnWriteArraySet继承了AbstractSet抽象类，AbstractSet提供 Set 接口的骨干实现，从而最大限度地减少了实现此接口所需的工作；同时实现了Serializable接口，表示可以序列化。

类的属性

public class CopyOnWriteArraySet<E> extends AbstractSet<E>
        implements java.io.Serializable {
    // 版本序列号
    private static final long serialVersionUID = 5457747651344034263L;
    // 由其对CopyOnWriteArraySet提供支持
    private final CopyOnWriteArrayList<E> al;
}

说明：其属性中包含了一个CopyOnWriteArrayList类型的变量al，对CopyOnWriteArraySet的操作会转发至al上执行。

类的构造函数

CopyOnWriteArraySet()型构造函数

    public CopyOnWriteArraySet() {
        // 初始化al
        al = new CopyOnWriteArrayList<E>();
    }

说明：此构造函数用于创建一个空 set。

CopyOnWriteArraySet(Collection<? extends E>)型构造函数

    public CopyOnWriteArraySet(Collection<? extends E> c) {
        if (c.getClass() == CopyOnWriteArraySet.class) { // c集合为CopyOnWriteArraySet类型
            // 初始化al
            @SuppressWarnings("unchecked") CopyOnWriteArraySet<E> cc =
                (CopyOnWriteArraySet<E>)c;
            al = new CopyOnWriteArrayList<E>(cc.al);
        }
        else { // c集合不为CopyOnWriteArraySet类型
            // 初始化al
            al = new CopyOnWriteArrayList<E>();
            // 添加c集合(c集合的元素在al中部存在时，才会添加)
            al.addAllAbsent(c);
        }
    }

说明：此构造函数用于创建一个包含指定 collection 所有元素的 set。处理流程如下:

判断集合c的类型是否为CopyOnWriteArraySet类型，若是，则获取c的al，并且初始当前CopyOnWriteArraySet的al域（调用CopyOnWriteArrayList的构造函数），否则，进入步骤②
新生CopyOnWriteArrayList，并赋值给al，之后调用addAllIfAbsent函数（al中不存在的元素，才添加）。

核心函数分析

由于对CopyOnWriteArraySet的操作（如add、remove、clear等）都转化为对CopyOnWriteArrayList的操作，所以在此不再进行讲解。
需要注意的是：CopyOnWriteArraySet在add时每次都要进行数组的遍历，因此其性能会低于CopyOnWriteArrayList。

应用场景和缺点

CopyOnWrite并发容器用于读多写少的并发场景。但是同时也存在两个问题，即内存占用问题和数据一致性问题。所以在开发的时候需要注意一下。

内存占用问题。 因为CopyOnWrite的写时复制机制，所以在进行写操作的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象（注意:在复制的时候只是复制容器里的引用，只是在写的时候会创建新对象添加到新容器里，而旧容器的对象还在使用，所以有两份对象内存）。如果这些对象占用的内存比较大，比如说200M左右，那么再写入100M数据进去，内存就会占用300M，那么这个时候很有可能造成频繁的Yong GC和Full GC。之前我们系统中使用了一个服务由于每晚使用CopyOnWrite机制更新大对象，造成了每晚15秒的Full GC，应用响应时间也随之变长。

针对内存占用问题，可以通过压缩容器中的元素的方法来减少大对象的内存消耗，比如，如果元素全是10进制的数字，可以考虑把它压缩成36进制或64进制。或者不使用CopyOnWrite容器，而使用其他的并发容器，如ConcurrentHashMap。

数据一致性问题。 CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。

微笑看你哭

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java并发(二十一)——CopyOnWriteArrayList和CopyOnWriteArraySet

CopyOnWriteArrayListCopyOnWriteArrayList容器是Collections.synchronizedList(List list)的替代方案，CopyOnWriteArrayList在某些情况下具有更好的性能，考虑读远大于写的场景，如果把所有的读操作进行加锁，因为只有一个读线程能够获得锁，所以其他的读线程都必须等待，大大影响性能。CopyOnWriteArray...
复制链接

扫一扫

专栏目录