你知道Java中的CopyOnWriteArrayList吗？

最新推荐文章于 2024-03-11 10:10:05 发布

漫步星辰575654643

最新推荐文章于 2024-03-11 10:10:05 发布

阅读量127

点赞数

本文链接：https://blog.csdn.net/good575654643/article/details/103975501

版权

CopyOnWrite

CopyOnWrite是什么？
CopyOnWriteArrayList源码分享？
CopyOnWriteArrayList使用场景？
CopyOnWriteArrayList有什么优缺点？

如果你是求职者，你想想看怎么回答上面的问题？

缘由

前段时间面试好多个人，问是否用过CopyOnWriteList,发现好多人都没有用过，感觉挺惊讶的。

CopyOnWrite看字面意思大概就可以明白了,copy集合之后再进行write操作，我们也称这个为写时复制容器。

这个从 JDK 1.5版本就已经有了，Java并发包中有两个实现这个机制的容器，分别是
CopyOnWriteArrayList和CopyOnWriteArraySet。

CopyOnWrite这个容器非常有用，特别是在并发的时候能够提升效率，很多并发的的场景中都可以用到CopyOnWrite的容器，我们在生产环境也用到过，今天托尼就和大家顺便讲讲这个容器。

CopyOnWrite是什么

官方解释
CopyOnWriteArrayList 是ArrayList的线程安全方式的一种方式。它的add、set方法底层实现都是重新复制一个新的容器来操作的。

CopyOnWriteArrayList 与ArrayList不同之处在于添加元素的时候会加上锁。

CopyOnWriteArrayList在修改容器元素的时候并不是直接在原来的数组上进行修改，它是先拷贝一份，然后在拷贝的数组上进行修改，在修改完成之后将引用赋给原来的数组。

CopyOnWriteArrayList源码分享

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

实现了List接口，List的一种实现方式
实现RandomAccess接口，看名称就知道随机访问，和数组访问一样根据下标
实现Cloneable接口，代表可以克隆
实现了Serializable接口接口，代表可以被序列化

当容器被初始化添加元素成功之后，多个线程读取容器中的元素，如果此刻没有元素的添加，并发多个线程读取出来的数据大家都是一样的，可以理解为线程安全的。

如果此刻有个线程往容器中添加一个新的元素，这个时候CopyOnWriteArrayList就会拷贝一个新的数组出来，将新的元素添加到新的数组中。

在添加元素的这段时间里，如果多线程访问容器中的元素，将会读取到旧的数据，等添加元素成功之后会将新的引用地址赋值给旧的list引用地址。

代码分享：

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

大家要注意上面的代码中ReentrantLock，在添加新元素的时候有加锁操作，多线程的情况下防止产生脏数据。

get方法

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

读的时候不会加锁，写的时候会加上锁，这个时候如果多线程正好写数据，读取的时候还是会读取到旧的数据。

set方法

 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
            //为了确保 voliatile 的语义，所以尽管写操作没有改变数据，还是调用set方法
            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)  
            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();  
    }  
}

同样也很简单，都是使用 System.arraycopy、Arrays.copyOf移动元素进行元素的删除操作。

CopyOnWriteArrayList迭代

针对iterator使用了一个叫COWIterator的迭代器，专门针对CopyOnWrite的迭代器，因为不支持写操作，如上面add、set、remove都会抛出异常，都是不支持的。

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

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

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

举个例子

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
list.add("a");
list.add("b");
list.add("c");

Iterator<String> iterator = list.iterator();
while(iterator.hasNext()) {
    String next = iterator.next();
       // 这句会报错的⚠️
    iterator.remove();
}

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.concurrent.CopyOnWriteArrayList$COWIterator.remove(CopyOnWriteArrayList.java:1178)