CopyOnWriteArrayList源码学习(jdk8)

Myth丶恋晨 2024-03-22 13:04 32阅读 0赞

> CopyOnWriteArrayList是一个线程安全的集合类，它的底层也是数组，和ArrayList是一样的，但是不同是ArrayList是线程不安全，不能用于多线程中，而CopyOnWriteArrayList是线程安全的。

#### CopyOnWriteArrayList的属性 ####

/** The lock protecting all mutators */
    	// 从这个可以看出CopyOnWriteArrayList的线程安全是通过ReentrantLock加锁来实现的
        final transient ReentrantLock lock = new ReentrantLock();
    
        /** The array, accessed only via getArray/setArray. */
        // array这个属性,就是底层的数组,这个属性加上了volatile关键字,保证了array的可见性,和有序性
        private transient volatile Object[] array;

#### CopyOnWriteArrayList的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(); // 解锁,在finally中,保证一定释放锁
            }
        }

#### CopyOnWriteArrayList的get()方法，阅读源码发现，读这个操作是不需要加锁的，直接读取array数组中的数据。(get(int index)源码并没有判断下标是否会越界) ####

/**
         * 读取数据操作
         */
        public E get(int index) {
        
        	// getArray()是得到array这个数组,直接是 array[index]
            return get(getArray(), index);
        }
    	private E get(Object[] a, int index) {
        
            return (E) a[index];
        }

#### CopyOnWriteArrayList的remove()方法，删除方法是，创建一个新数组，然后将旧数组数组复制到新数组中，复制的时候，不复制要删除的元素。因此复制的时候会判断删除的元素是否是最后一个元素，如果是复制的时候直接不复制就行，如果不是，则需要很两段进行复制。(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 {
         // 不是删除最后一个元素
                    Object[] newElements = new Object[len - 1]; // 新数组
                    // System.arraycopy()是一个native方法,这个方法是用来复制数组的数据的,
                    // arraycopy(被复制的数组,开始复制的下标,复制到哪个数组,从这个数组的哪个下标开始粘贴,复制的长度)
                   // 以index为分界线,分两段开始复制
                    System.arraycopy(elements, 0, newElements, 0, index); //复制前半段
                    System.arraycopy(elements, index + 1, newElements, index,
                                     numMoved); // 复制后半段
                    setArray(newElements); // 新数组替代旧数组
                }
                return oldValue; // 返回被删除的值
            } finally {
        
                lock.unlock(); // 解锁
            }
        }

#### 总结 ####

> CopyOnWriteArrayList在操作元素的时候，读写是分离开的，写的时候会创建一个新的数组，将旧数组元素复制到新数组中，然后将要添加的元素添加到新数组，之后新数组替代旧数组。而读的时候，直接根据下标读取元素，不会被写操作给阻塞。删除操作和写操作类似，也是创建一个新数组，但是删除需要判断，如果是删除最后一个元素，就直接复制元素，不复制最后一个就行，但是大多情况下，删除的不是最后一个元素，需要以index很分割线，分为两段进行复制到新数组中。  
> 写操作是加锁的，读操作是不加锁的，这样读写分离可以有效的提高效率，但是这样会有一个数据一致性的问题，就是在并发情况下，一个线程，写操作添加数据，一个读操作，读取数据，可能读操作读取了旧数组的数组，导致数据不一致。（虽然array属性加入volatile关键字，但是这个写操作是先在新数组操作，然后复制到旧数组，新数组是没法对其他线程可见的。）