关于java:java中CopyOnWriteArrayList详解

40次阅读

共计 5573 个字符,预计需要花费 14 分钟才能阅读完成。

简介

CopyOnWriteArrayList 是 ArrayList 的线程平安版本,外部也是通过数组实现,每次对数组的批改都齐全拷贝一份新的数组来批改,批改完了再替换掉老数组,这样保障了只阻塞写操作,不阻塞读操作,实现读写拆散。

继承体系

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable 
    {...}
  • CopyOnWriteArrayList 实现了 List,RandomAccess,Cloneable,java.io.Serializable 等接口。
  • CopyOnWriteArrayList 实现了 List,提供了根底的增加、删除、遍历等操作。
  • CopyOnWriteArrayList 实现了 RandomAccess,提供了随机拜访的能力。
  • CopyOnWriteArrayList 实现了 Cloneable,能够被克隆。
  • CopyOnWriteArrayList 实现了 Serializable,能够被序列化。

源码解析

属性

/** 用于批改时加锁 */
final transient ReentrantLock lock = new ReentrantLock();

/** 真正存储元素的中央,只能通过 getArray()/setArray()拜访 */
private transient volatile Object[] array;
  • lock:批改时加锁,应用 transient 润饰示意不主动序列化。
  • array:存储元素的中央,应用 transient 润饰示意不主动序列化,应用 volatile 润饰示意一个线程对这个字段的批改另外一个线程立刻可见。

构造方法

创立空数组。

public CopyOnWriteArrayList() {// 所有对 array 的操作都是通过 setArray()和 getArray()进行
    setArray(new Object[0]);
}

final void setArray(Object[] a) {array = a;}
public CopyOnWriteArrayList(Collection<? extends E> c) {Object[] elements;
    if (c.getClass() == CopyOnWriteArrayList.class)
        // 如果 c 也是 CopyOnWriteArrayList 类型
        // 那么间接把它的数组拿过去应用
        elements = ((CopyOnWriteArrayList<?>)c).getArray();
    else {// 否则调用其 toArray()办法将汇合元素转化为数组
        elements = c.toArray();
        // 这里 c.toArray()返回的不肯定是 Object[]类型
        // 具体起因见 ArrayList 外面的剖析
        if (elements.getClass() != Object[].class)
            elements = Arrays.copyOf(elements, elements.length, Object[].class);
    }
    setArray(elements);
}
  • 如果 c 是 CopyOnWriteArrayList 类型,间接把它的数组赋值给以后 list 的数组,留神这里是浅拷贝,两个汇合共用同一个数组。
  • 如果 c 不是 CopyOnWriteArrayList 类型,则进行拷贝把 c 的元素全副拷贝到以后 list 的数组中。
public CopyOnWriteArrayList(E[] toCopyIn) {setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}
  • 把 toCopyIn 的元素拷贝给以后 list 的数组。

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();}
}
  1. 加锁;
  2. 获取元素数组;
  3. 新建一个数组,大小为原数组长度加 1,并把原数组元素拷贝到新数组;
  4. 把新增加的元素放到新数组的开端;
  5. 把新数组赋值给以后对象的 array 属性,笼罩原数组;
  6. 解锁。

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;
        // 查看是否越界, 能够等于 len
        if (index > len || index < 0)
            throw new IndexOutOfBoundsException("Index:"+index+
                                                ", Size:"+len);
        Object[] newElements;
        int numMoved = len - index;
        if (numMoved == 0)
            // 如果插入的地位是最初一位
            // 那么拷贝一个 n + 1 的数组, 其前 n 个元素与旧数组统一
            newElements = Arrays.copyOf(elements, len + 1);
        else {
            // 如果插入的地位不是最初一位
            // 那么新建一个 n + 1 的数组
            newElements = new Object[len + 1];
            // 拷贝旧数组前 index 的元素到新数组中
            System.arraycopy(elements, 0, newElements, 0, index);
            // 将 index 及其之后的元素往后挪一位拷贝到新数组中
            // 这样正好 index 地位是空进去的
            System.arraycopy(elements, index, newElements, index + 1,
                             numMoved);
        }
        // 将元素搁置在 index 处
        newElements[index] = element;
        setArray(newElements);
    } finally {
        // 开释锁
        lock.unlock();}
}
  1. 加锁;
  2. 查看索引是否非法,如果不非法抛出 IndexOutOfBoundsException 异样,留神这里 index 等于 len 也是非法的;
  3. 如果索引等于数组长度(也就是数组最初一位再加 1),那就拷贝一个 len+1 的数组;
  4. 如果索引不等于数组长度,那就新建一个 len+1 的数组,并按索引地位分成两局部,索引之前(不蕴含)的局部拷贝到新数组索引之前(不蕴含)的局部,索引之后(蕴含)的地位拷贝到新数组索引之后(不蕴含)的地位,索引所在位置留空;
  5. 把索引地位赋值为待增加的元素;
  6. 把新数组赋值给以后对象的 array 属性,笼罩原数组;
  7. 解锁;

addIfAbsent(E e)办法

增加一个元素如果这个元素不存在于汇合中。

public boolean addIfAbsent(E e) {
    // 获取元素数组, 取名为快照
    Object[] snapshot = getArray();
    // 查看如果元素不存在, 间接返回 false
    // 如果存在再调用 addIfAbsent()办法增加元素
    return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
        addIfAbsent(e, snapshot);
}

private boolean addIfAbsent(E e, Object[] snapshot) {
    final ReentrantLock lock = this.lock;
    // 加锁
    lock.lock();
    try {
        // 从新获取旧数组
        Object[] current = getArray();
        int len = current.length;
        // 如果快照与刚获取的数组不统一
        // 阐明有批改
        if (snapshot != current) {
            // 从新查看元素是否在刚获取的数组里
            int common = Math.min(snapshot.length, len);
            for (int i = 0; i < common; i++)
                // 到这个办法外面了, 阐明元素不在快照外面
                if (current[i] != snapshot[i] && eq(e, current[i]))
                    return false;
            if (indexOf(e, current, common, len) >= 0)
                    return false;
        }
        // 拷贝一份 n + 1 的数组
        Object[] newElements = Arrays.copyOf(current, len + 1);
        // 将元素放在最初一位
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        // 开释锁
        lock.unlock();}
}
  1. 查看这个元素是否存在于数组快照中;
  2. 如果存在间接返回 false,如果不存在调用 addIfAbsent(E e, Object[] snapshot) 解决;
  3. 加锁;
  4. 如果以后数组不等于传入的快照,阐明有批改,查看待增加的元素是否存在于以后数组中,如果存在间接返回 false;
  5. 拷贝一个新数组,长度等于原数组长度加 1,并把原数组元素拷贝到新数组中;
  6. 把新元素增加到数组最初一位;
  7. 把新数组赋值给以后对象的 array 属性,笼罩原数组;
  8. 解锁;

get(int index)

获取指定索引的元素,反对随机拜访,工夫复杂度为 O(1)。

public E get(int index) {
    // 获取元素不须要加锁
    // 间接返回 index 地位的元素
    // 这里是没有做越界查看的, 因为数组自身会做越界查看
    return get(getArray(), index);
}

final Object[] getArray() {return array;}

private E get(Object[] a, int index) {return (E) a[index];
}
  1. 获取元素数组;
  2. 返回数组指定索引地位的元素;

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)
            // 如果移除的是最初一位
            // 那么间接拷贝一份 n - 1 的新数组, 最初一位就主动删除了
            setArray(Arrays.copyOf(elements, len - 1));
        else {
            // 如果移除的不是最初一位
            // 那么新建一个 n - 1 的新数组
            Object[] newElements = new Object[len - 1];
            // 将前 index 的元素拷贝到新数组中
            System.arraycopy(elements, 0, newElements, 0, index);
            // 将 index 前面 (不蕴含) 的元素往前挪一位
            // 这样正好把 index 地位笼罩掉了, 相当于删除了
            System.arraycopy(elements, index + 1, newElements, index,
                             numMoved);
            setArray(newElements);
        }
        return oldValue;
    } finally {
        // 开释锁
        lock.unlock();}
}
  1. 加锁;
  2. 获取指定索引地位元素的旧值;
  3. 如果移除的是最初一位元素,则把原数组的前 len- 1 个元素拷贝到新数组中,并把新数组赋值给以后对象的数组属性;
  4. 如果移除的不是最初一位元素,则新建一个 len- 1 长度的数组,并把原数组除了指定索引地位的元素全副拷贝到新数组中,并把新数组赋值给以后对象的数组属性;
  5. 解锁并返回旧值;

size()办法

返回数组的长度。

public int size() {
    // 获取元素个数不须要加锁
    // 间接返回数组的长度
    return getArray().length;}

发问

为什么 CopyOnWriteArrayList 没有 size 属性?

因为每次批改都是拷贝一份正好能够存储指标个数元素的数组,所以不须要 size 属性了,数组的长度就是汇合的大小,而不像 ArrayList 数组的长度理论是要大于汇合的大小的。比方,add(E e)操作,先拷贝一份 n + 1 个元素的数组,再把新元素放到新数组的最初一位,这时新数组的长度为 len+ 1 了,也就是汇合的 size 了。

总结

  1. CopyOnWriteArrayList 应用 ReentrantLock 重入锁加锁,保障线程平安;
  2. CopyOnWriteArrayList 的写操作都要先拷贝一份新数组,在新数组中做批改,批改完了再用新数组替换老数组,所以空间复杂度是 O(n),性能比拟低下;
  3. CopyOnWriteArrayList 的读操作反对随机拜访,工夫复杂度为 O(1);
  4. CopyOnWriteArrayList 采纳读写拆散的思维,读操作不加锁,写操作加锁,且写操作占用较大内存空间,所以实用于读多写少的场合;
  5. CopyOnWriteArrayList 只保障最终一致性,不保障实时一致性。

正文完
 0