CopyOnWriteArrayList

用法示例

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @author admin
 */
public class CopyOnWtiteArrayListDemo {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<Integer> copyOnWriteArrayList = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {
            copyOnWriteArrayList.add(i);
        }
        new Thread(()->{
            for (int i = 0; i < copyOnWriteArrayList.size(); i++) {
                try{
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "输出元素:" + copyOnWriteArrayList.get(i));
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i < copyOnWriteArrayList.size(); i++) {
                try{
                    Thread.sleep(800);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (copyOnWriteArrayList.get(i) % 2 == 0){
                    System.out.println(Thread.currentThread().getName() + "删除元素:" + copyOnWriteArrayList.remove(i));
                }
            }
        }).start();
        Thread.sleep(10000);
        Iterator<Integer> iterator = copyOnWriteArrayList.iterator();
        while (iterator.hasNext()){
            Integer integer = iterator.next();
            System.out.println("copyOnWriteArrayList剩余元素：" + integer);
        }
    }
}

CopyOnWriteArrayList声明

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

CopyOnWriteArrayList属性

    /** 可重入锁 */
    final transient ReentrantLock lock = new ReentrantLock();

    /** 存储数据的底层数组 */
    /** 要注意的是这里是用volatile修饰的数组*/
    private transient volatile Object[] array;

CopyOnWriteArrayList构造器

    /**
     * 创建空的list
     */
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

    /**
     * 指定集合作为参数的 构造器
     */
    public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements;
        if (c.getClass() == CopyOnWriteArrayList.class)
            elements = ((CopyOnWriteArrayList<?>)c).getArray();
        else {
            elements = c.toArray();
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elements.getClass() != Object[].class)
                elements = Arrays.copyOf(elements, elements.length, Object[].class);
        }
        setArray(elements);
    }

    /**
     * 指定数组为参数的构造器
     */
    public CopyOnWriteArrayList(E[] toCopyIn) {
        setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
    }

add()方法

	/**
	*在list尾部添加元素
	*/
    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);
            //新数组最后一个位置存插入的元素e
            newElements[len] = e;
            //修改数组引用
            setArray(newElements);
            //返回添加成功
            return true;
        } finally {
        	//解锁
            lock.unlock();
        }
    }

重载的add()方法

    public void add(int index, E element) {
        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);
            Object[] newElements;
            int numMoved = len - index;
            //如果是在list的末尾插入元素
            if (numMoved == 0)
                newElements = Arrays.copyOf(elements, len + 1);
            else {
            	//如果不是在list的末尾插入元素
                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();
        }
    }

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);
                //更新index位置元素值
                newElements[index] = element;
                setArray(newElements);
            } else {
                // Not quite a no-op; ensures volatile write semantics
                setArray(elements);
            }
            return oldValue;
        } 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;
            //如果删除的是list最后一个元素
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, len - 1));
            else {
            	//如果删除的不是list最后一个元素
                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();
        }
    }

重载的remove()方法

    public boolean remove(Object o) {
        Object[] snapshot = getArray();
        //查找要删除的元素的位置
        int index = indexOf(o, snapshot, 0, snapshot.length);
        //调用重载的remove()方法删除元素
        return (index < 0) ? false : remove(o, snapshot, index);
    }

get()方法

    public E get(int index) {
        return get(getArray(), index);
    }

indeOf()方法

    public int indexOf(E e, int index) {
        Object[] elements = getArray();
        //调用重载的私有的indexOf()方法
        return indexOf(e, elements, index, elements.length);
    }
    //调用重载的私有的indexOf()方法
        private static int indexOf(Object o, Object[] elements,
                               int index, int fence) {
        //判断删除的值是否为空
        if (o == null) {
        	
            for (int i = index; i < fence; i++)
                if (elements[i] == null)
                    return i;
        } else {
            for (int i = index; i < fence; i++)
                if (o.equals(elements[i]))
                    return i;
        }
        return -1;
    }

重载的indeOf()方法

    public int indexOf(E e, int index) {
        Object[] elements = getArray();
        return indexOf(e, elements, index, elements.length);
    }