关于线程安全集合CopyOnWriteArrayList部分源码分析

x.y.r

已于 2022-09-17 22:07:48 修改

阅读量282

点赞数 14

文章标签： java 开发语言

于 2022-09-17 22:05:15 首次发布

本文链接：https://blog.csdn.net/wan25110712/article/details/126910746

版权

分析源码之前，先来介绍一下CopyOnWriteArrayList是什么？？

首先从名字上可以看出它是基于数组的集合实现类，它继承自List接口，再来说说它名字的前缀：CopyOnWrite（简称COW），copy翻译为复制，那CopyOnWrite就可以理解为是在“写”的时候进行复制操作，那就不难理解它的实现原理：

就是说，CopyOnWriteArrayList在实现写操作时，不会直接在原数组上进行修改，而是会创建一个新数组，并复制原数组内容至新数组再进行写操作。这样做的好处就是，多线程并发时，其中一个线程在对数组进行修改的同时，不会被别的线程影响，并且不会影响其他线程对原数组进行“读”的操作。

所以，CopyOnWriteArrayList是一种用于集合的并发访问的优化策略。

了解完CopyOnWriteArrayList的基本概念和实现原理，下面就来进入源码分析：

1、首先来看看下面的代码：

可以看到它初始化了Reentrantlook安全锁，用于后续方法中对操作加锁，保线程安全。

在创建默认Object数组时使用了volatile关键字，保证了数组被修改时的可见性。

getArray()用于得到当前集合中的默认数组，setArray()用于存将默认数组重新指向传入的修改后的数组。

2、两个构造方法：

CopyOnWriteArrayList()：无参构造方法，用于初始化自定义数组


    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

CopyOnWriteArrayList(Collection<? extends E> c)：有参构造方法，将传入的集合collection转化为数组存入自定义数组

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

3、set(int index, E element)：用于根据目标下标，修改指定下标元素为参数中传入的元素

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

4、add(E e)：添加元素至数组末尾

public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
			// 获取原数组
            Object[] elements = getArray();
            int len = elements.length;
			// 定义比原数组长度多1的新数组并复制原数组内容
            Object[] newElements = Arrays.copyOf(elements, len + 1);
			// 将传入元素存入新数组最后
            newElements[len] = e;
			// 保存新数组
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

5、add(int index, E element)：添加元素至指定下标

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)
				// 如果是创建比原数组长度多1的新数组，则直接复制原数组至新数组
                newElements = Arrays.copyOf(elements, len + 1);
            else {
				// 创建比原数组长度多1的新数组
                newElements = new Object[len + 1];
				// 复制目标下标前的数组元素至新数组
                System.arraycopy(elements, 0, newElements, 0, index);
				// 复制目标下标后的数组元素至新数组，并制定复制个数
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);
            }
			// 添加新元素至指定下标
            newElements[index] = element;
            setArray(newElements);
        } finally {
            lock.unlock();
        }
    }

6、remove(int index)：根据下标删除目标元素

 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 {
				// 创建比原数组长度少1的新数组
                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();
        }
    }

7、removeRange(int fromIndex, int toIndex)：用于删除指定区间内的元素

void removeRange(int fromIndex, int toIndex) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
			// 判断区间是否合法，否则抛出异常
            if (fromIndex < 0 || toIndex > len || toIndex < fromIndex)
                throw new IndexOutOfBoundsException();
			// 计算新数组长度及数组尾部移动元素个数
            int newlen = len - (toIndex - fromIndex);
            int numMoved = len - toIndex;
			// 判断是否删除至数组末尾
            if (numMoved == 0)
				// 复制并存储首元素至删除区间前一个元素
                setArray(Arrays.copyOf(elements, newlen));
            else {
				// 创建新长度数组
                Object[] newElements = new Object[newlen];
				// 分步复制区间前后数组元素
                System.arraycopy(elements, 0, newElements, 0, fromIndex);
                System.arraycopy(elements, toIndex, newElements,
                                 fromIndex, numMoved);
                setArray(newElements);
            }
        } finally {
            lock.unlock();
        }
    }

8、retainAll(Collection<?> c)：参数中传入一个集合，若原数组中存在该集合中的元素则保留，否则删除

public boolean retainAll(Collection<?> c) {
		// 判断传入集合是否为空
        if (c == null) throw new NullPointerException();
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
			// 判断原数组长度不为0则继续
            if (len != 0) {
                // temp array holds those elements we know we want to keep
				// 定义新数组长度为0并创临时建新数组
                int newlen = 0;
                Object[] temp = new Object[len];
				// 遍历元素组
                for (int i = 0; i < len; ++i) {
					// 去除原数组本轮循环的值
                    Object element = elements[i];
					// 判断传入集合是否存在该值
                    if (c.contains(element))
						// 存在则存入新数组，新数组长度++
                        temp[newlen++] = element;
                }
				// 判断原数组长度是否与新数组长度一致
                if (newlen != len) {
					// 不一致则复制新数组并存储
                    setArray(Arrays.copyOf(temp, newlen));
                    return true;
                }
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

9、clear()：清空数组

public void clear() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
			// 将原数组替换为新的空数组
            setArray(new Object[0]);
        } finally {
            lock.unlock();
        }
    }

10、addAll(int index, Collection<? extends E> c)：传入一个集合，从指定下标开始，存入传入的集合中的所有元素存

public boolean addAll(int index, Collection<? extends E> c) {
		// 将传入集合转为数组
        Object[] cs = c.toArray();
        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);
			// 判断传入集合是否为空
            if (cs.length == 0)
                return false;
			// 计算要移动的元素个数
            int numMoved = len - index;
			// 创建新数组
            Object[] newElements;
			// 判断是否从原数组尾部添加
            if (numMoved == 0)
				// 复制原数组至新数组，并给新数组设置长度
                newElements = Arrays.copyOf(elements, len + cs.length);
            else {
				// 初始化并设置新数组长度
                newElements = new Object[len + cs.length];
				// 从原数组中复制指定下标前的元素至新数组
                System.arraycopy(elements, 0, newElements, 0, index);
				// 从原数组中复制剩下元素至新数组index + cs.length下标位置
                System.arraycopy(elements, index,
                                 newElements, index + cs.length,
                                 numMoved);
            }
			// 从新数组index位置开始复制传入集合数组元素
            System.arraycopy(cs, 0, newElements, index, cs.length);
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

x.y.r

关注

14
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
关于线程安全集合CopyOnWriteArrayList部分源码分析

CopyOnWriteArrayList是一种用于集合的并发访问的优化策略。在实现写操作时，不会直接在原数组上进行修改，而是会创建一个新数组，并复制原数组内容至新数组再进行写操作。这样做的好处就是，多线程并发时，其中一个线程在对数组进行修改的同时，不会被别的线程影响，并且不会影响其他线程对原数组进行“读”的操作......
复制链接

扫一扫