jdk源码解析三之CopyOnWriteArrayList

末蓝、 2023-02-20 12:07 34阅读 0赞

### 文章目录 ###

*   *  CopyOnWriteArrayList
     *   *  add
         *  remove
         *  get
         *  set
     *  总结

## CopyOnWriteArrayList ##

写入时复制,只要正确发布一个事实不可变对象,在访问该对象时就不再需要进一步同步,在每次修改时,都会创建并重新发布一个新的容器副本,从而实现可变性.  
使用场景:迭代>修改,事件通知系统(注册和注销事件监听器操作少于接收事件通知的操作)

//构造时,初始化容量为0的Object数组
        public CopyOnWriteArrayList() {
        
            setArray(new Object[0]);
        }

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

### 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;
                //最后一个数组索引,则直接copy
                if (numMoved == 0)
                    setArray(Arrays.copyOf(elements, len - 1));
                else {
        
                    //copy2次
                    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();
            }
        }

### get ###

public E get(int index) {
        
            return get(getArray(), index);
        }
        private E get(Object[] a, int index) {
        
            return (E) a[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
                     //保证最终一致性
                    setArray(elements);
                }
                return oldValue;
            } finally {
        
                lock.unlock();
            }
        }

## 总结 ##

应用场景:读多写少  
如:黑名单,监听器

读上没加锁,所以支持大量并发,但涉及修改的时候,有2个数组副本,当数组过大,则造成多余的内存消耗.

CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。之所以只能保证最终一致,是因为每次涉及到修改都会copy一个副本然后回写,最终的结果是一致的,但是在copy途中如果有读操作,那么就会造成数据不一致问题.