并发容器学习—CopyOnWriteArrayList与CopyOnWriteArraySet

最新推荐文章于 2025-06-09 09:54:35 发布

转载最新推荐文章于 2025-06-09 09:54:35 发布 · 151 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/bzhangpoorman/blog/3044787

文章标签：

#python #java #数据结构与算法

本文主要介绍了CopyOnWriteArrayList并发容器，包括其底层数据结构为数组，增删改通过复制数组实现，读写分离，写加锁、读无锁，适合读多写少场景。还提到CopyOnWriteArraySet底层由CopyOnWriteArrayList实现，特点类似。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

2019独角兽企业重金招聘Python工程师标准>>>

一、CopyOnWriteArrayList并发容器

1.CopyOnWriteArrayList的底层数据结构

CopyOnWriteArrayList的底层实现是数组，CopyOnWriteArrayList是ArrayList的一个线程安全的变体，其增删改操作都是通过对底层数组的重新复制来实现的。这种容器内存开销很大，但是在读操作频繁（查询），写操作（增删改）极少的场合却极用，并且每一次写操作都是在一块新的空间上进行的，不存在并发问题。

2.CopyOnWriteArrayList的继承关系

CopyOnWriteArrayList继承关系如下图所示，List接口和Collection接口在学习ArrayList时已经分析过，不在多说。

3.重要属性和构造方法

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

    //可重入锁
    final transient ReentrantLock lock = new ReentrantLock();

    //底层实现，用于存放数据的数组
    private transient volatile Object[] array;

    //获取数组
    final Object[] getArray() {
        return array;
    }

    //修改数组
    final void setArray(Object[] a) {
        array = a;
    }

    //默认构造器，初始化一个长度为0 的数组
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

    //将集合c中所有元素转化成数组的形式，存储与当前List中
    public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements;
        if (c.getClass() == CopyOnWriteArrayList.class)
            elements = ((CopyOnWriteArrayList<?>)c).getArray();
        else {
            elements = c.toArray();
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elements.getClass() != Object[].class)
                elements = Arrays.copyOf(elements, elements.length, Object[].class);
        }
        setArray(elements);
    }

    //将数组toCopyIn拷贝以一份到array中
    public CopyOnWriteArrayList(E[] toCopyIn) {
        setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
    }
}

4.add与set过程

CopyOnWriteArrayList在新增元素时，会先进行加锁操作，以保证写操作的并发安全

//将新增数据加到数组末尾
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();    //解锁
    }
}

//新增元素到指定位置
public void add(int index, E element) {
    final ReentrantLock lock = this.lock;    //获取重入锁
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        if (index > len || index < 0)    //判断索引是否合法
            throw new IndexOutOfBoundsException("Index: "+index+
                                                ", Size: "+len);
        Object[] newElements;
        int numMoved = len - index;
        //判断插入的位置是否是数组末尾
        if (numMoved == 0)    
            newElements = Arrays.copyOf(elements, len + 1);
        else {
            newElements = new Object[len + 1];
            //将原数组中0到index的元素复制到新数组的0到index位置
            System.arraycopy(elements, 0, newElements, 0, index);
            //将原数组的index之后的数据复制到新数组的index+1位置之后
            System.arraycopy(elements, index, newElements, index + 1,
                             numMoved);
        }
        newElements[index] = element;    //新增element
        setArray(newElements);
    } finally {
        lock.unlock();
    }
}

//修改index索引上的数据
public E set(int index, E element) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        E oldValue = get(elements, index);


        if (oldValue != element) {
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len);
            newElements[index] = element;
            setArray(newElements);
        } else {
            // Not quite a no-op; ensures volatile write semantics
            setArray(elements);
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}

5.get的过程

CopyOnWriteArrayList的读取过程并没加锁，这是因为CopyOnWriteArrayList的读过程是天然线程安全的，所有的写操作都是在一块新的内存空间上，而读操作则是在原有的空间上进行的，不会出现并发问题，读写天然分离。

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

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

6.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)
            setArray(Arrays.copyOf(elements, len - 1));
        else {
            Object[] newElements = new Object[len - 1];
            System.arraycopy(elements, 0, newElements, 0, index);
            System.arraycopy(elements, index + 1, newElements, index,
                             numMoved);
            setArray(newElements);
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}

//将o从数组中删除
public boolean remove(Object o) {
    Object[] snapshot = getArray();
    int index = indexOf(o, snapshot, 0, snapshot.length);    //获取o的索引位置
    
    //判断index是否合法
    return (index < 0) ? false : remove(o, snapshot, index);
}

//将snapshot中index位置的数据o删除
private boolean remove(Object o, Object[] snapshot, int index) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] current = getArray();    //获取当前数组
        int len = current.length;
        
        //判断数组是否发生改变，即是否有其他线程将数组修改了
        if (snapshot != current) findIndex: {
            //比较修改后的数组长度与index索引的大小，取小的值
            int prefix = Math.min(index, len);

            //遍历current数组查找第一个与快照数组元素不同的索引
            for (int i = 0; i < prefix; i++) {
                if (current[i] != snapshot[i] && eq(o, current[i])) {
                    index = i;
                    break findIndex;
                }
            }

            //o元素索引大于等于current数组的长度
            //说明current数组中不存在o元素
            if (index >= len)
                return false;

            //o元素的索引仍在current数组中
            //且要删除元素的索引的没有发生改变
            if (current[index] == o)
                break findIndex;

            //o元素索引发生改变，重新获取o元素的索引
            index = indexOf(o, current, index, len);
            if (index < 0)
                return false;
        }
        Object[] newElements = new Object[len - 1];
        System.arraycopy(current, 0, newElements, 0, index);
        System.arraycopy(current, index + 1,
                         newElements, index,
                         len - index - 1);
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

7.总结

由上面的分析可得出CopyOnWriteArrayList具有如下特点：

1.CopyOnWriteArrayList是线程安全的容器，读写分离，写数据时通过ReentrantLock锁定一个线程拷贝数组元素进行增删改操作；读数据时则不需要同步控制。

2.CopyOnWriteArrayList中是允许null数据和重复数据的

3.CopyOnWriteArrayList的并发安全性是通过创建新的数组和重入锁实现的，会耗费大量内存空间，只适合读多谢写少，数据量不大的环境。

二、CopyOnWriteArraySet并发容器

1.CopyOnWriteArraySet

由于CopyOnWriteArraySet的底层是通过CopyOnWriteArrayList来实现的，其特点与CopyOnWriteArrayList，因此不再做过多的分析。

转载于:https://my.oschina.net/bzhangpoorman/blog/3044787