CopyOnWriteArrayList源码分析

最新推荐文章于 2024-08-24 22:01:16 发布

只为冬

最新推荐文章于 2024-08-24 22:01:16 发布

阅读量107

点赞数 7

文章标签： java eclipse

本文链接：https://blog.csdn.net/qq_64271154/article/details/126919099

版权

CopyOnWriteArrayList

首先，我们先大致了解一下什么是CopyOnWriteArrayList。

CopyOnWriteArrayList是一个线程安全的集合。当我们往一个集合容器中写入元素时（添加、修改、删除），并不会像之前的线程安全的方法一样，直接在方法上加锁，直接在集合容器中写入，而是先将当前集合容器进行Copy，复制出一个新的容器，然后在新的容器里写入元素，写入操作完成之后，再将原容器的引用指向新的容器。实现对CopyOnWrite集合容器写入操作时的线程安全，但同时并不影响进行并发的读取操作。

CopyOnWriteArrayList相当于线程安全的ArrayList，内部存储结构采用Object[]数组，线程安全使用ReentrantLock实现，允许多个线程并发读取，但只能有一个线程写入。

源码分析

// 创建ReentrantLock锁
final transient ReentrantLock lock = new ReentrantLock();

private transient volatile Object[] array;

// 返回Object类型的数组
final Object[] getArray() {
    return array;
}

// 使当前数组重新指向
final void setArray(Object[] a) {
    array = a;
}

构造方法

// 无参构造方法，创建一个空的Object数组
public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}

// 有参构造方法，传入一个集合，直接将集合内容复制到自己的数组
public CopyOnWriteArrayList(Collection<? extends E> c) {
    // 创建一个新Object数组
    Object[] elements;
    // 判断传入集合数组是否是CopyOnWriteArrayList类
    if (c.getClass() == CopyOnWriteArrayList.class)
        // 如果是，直接强制转换类型，让新创建的数组指向该数组
        elements = ((CopyOnWriteArrayList<?>)c).getArray();
    else {
        // 如果不是，将传入的集合转换为数组
        elements = c.toArray();
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        // 判断当前对象的class是否是Object
        if (elements.getClass() != Object[].class)
            // 复制当前数组
            elements = Arrays.copyOf(elements, elements.length, Object[].class);
    }
    // 更新该数组集合
    setArray(elements); 
}

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

add()：添加新元素

// 添加新元素
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();
    }
}

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;
        // 判断要加入的位置是否小于0或者是否大于数组长度
        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();
    }
}

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

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;
        // 判断要删除的元素数量是否为0
        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();
    }
}

retainAll(Collection<?> c)：判断集合间是否有交集并把原集合更新成交集

//判断集合间是否有交集并把原集合更新成交集
public boolean retainAll(Collection<?> c) {
	// 判断如果集合为空，抛出NullPointerException()异常
    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
            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();
    }
}

clear()：清空集合

// 清空集合
public void clear() {
	// 加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
		// 设置数组为空数组
        setArray(new Object[0]);
    } finally {
		// 解锁
        lock.unlock();
    }
}

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];
			// 从0开始复制index个元素
			System.arraycopy(elements, 0, newElements, 0, index);
			// 从原集合从index下标开始，结果集合从index+新数组长度开始复制numMoved个元素
            System.arraycopy(elements, index, newElements, index + cs.length, numMoved);
        }
		// 新数组从0开始，结果数组从index开始，复制新数组长度
        System.arraycopy(cs, 0, newElements, index, cs.length);
		// 设置数组为结果数组
        setArray(newElements);
        return true;
    } finally {
		// 解锁
        lock.unlock();
    }
}