ArrayList和CopyOnWriteArrayList

最新推荐文章于 2024-07-24 17:27:32 发布

weixin_44149903

最新推荐文章于 2024-07-24 17:27:32 发布

阅读量350

点赞数

分类专栏： Java集合文章标签： java

本文链接：https://blog.csdn.net/weixin_44149903/article/details/130384965

版权

Java集合专栏收录该内容

4 篇文章 0 订阅

订阅专栏

ArrayList源码

transient Object[] elementData;
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

默认大小空，什么时候开始有大小？
add方法

//这里看到add方法没有加任何锁，所以线程不安全的
 public boolean add(E e) {
 //size初始值0，这里开始+1，这里判断开始扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //将数据放到集合中
    elementData[size++] = e;
    return true;
}

//这里如果elementData=DEFAULTCAPACITY_EMPTY_ELEMENTDATA都是空，默认10
private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
    //源码默认是10大小
private static final int DEFAULT_CAPACITY = 10;

扩容

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //这里10+原来的一半，即为15，右移1位，相当于10除以2的一次幂，即为5（左移右移是最快的）
        //这里进行右移（>>）右移几位相当于除以2的几次幂；左移几位相当于乘以2的几次幂；
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        //这里将老数据放到新集合中
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

线程不安全，add方法没有加锁，为了保证并发效率。
多线程调用add方法会报错 ConcurrentModificationException并发修改异常

所以ArrayList是线程不安全的。可以看到源码里面没有任何线程安全的代码。

ArrayList线程不安全，如何解决

Vector线程安全，代码里加了synchonized关键字。但是Vector性能低，不用它
Collections.synchronizedList 不用
重点是下面这个
CopyOnWriteArrayList集合

CopyOnWriteArrayList集合，JUC中的类。写时复制集合类。

写时复制，主要是读写分离的思想。

底层加了ReentrantLock锁。
不是直接往当前容器object【】添加，而是先将当前容器进行复制copy，得倒一个新的object[],然后向新的容器添加元素，添加完成后将原来容器引用指向新的容器。

这样好处是可以对容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素

//˙这里volatile关键字
private transient volatile Object[] array;
    
final Object[] getArray() {
    return array;
}
public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            //又看到了copyof方法，复制出一个新的容器，向新的容器添加元素
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            //将原来容器引用指向新的容器
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }