ArrayList Collections.synchronizedList CopyOnWriteArrayList

一、ArrayList

    // 调用无参构造器时, 且在调用添加第一个元素时设置的默认大小
    private static final int DEFAULT_CAPACITY = 10;
    // 定义数组长度为0时, 缓存数组elementData=EMPTY_ELEMENTDATA 
    private static final Object[] EMPTY_ELEMENTDATA = {};
    // 调用无参构造器时的默认空数组, 缓存数组elementData=DEFAULTCAPACITY_EMPTY_ELEMENTDATA 
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    // 数据存放对象
    transient Object[] elementData; // non-private to simplify nested class access
    // 存放了多少个数据在数组中
    private int size;
    // 要分配的数组的最大大小。有些虚拟机在数组中保留一些头字。尝试分配更大的数组可能会导致OutOfMemoryError:请求的数组大小超过虚拟机限制
	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

1. 无参构造器
   
2. 指定数据大小的构造器，如果大于0创建一个新的数组，如果等于0，赋值默认大小的数组
   
3. 添加元素方法add(E e)

    public boolean add(E e) {
    	// 原数组大小+1
        ensureCapacityInternal(size + 1);  
        elementData[size++] = e;
        return true;
    }
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        	// 进入到if条件中, 是通过无参构造方法生成的且是第一次添加元素。取默认大小和szie+1后两个树中的最大值
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    private void ensureExplicitCapacity(int minCapacity) {
    	// 数据结构被修改的次数
        modCount++;

        // 如果添加元素后返回的大小大于数组的长度, 表示数组的长度不够, 则开始扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }  
	private void grow(int minCapacity) {
        // 旧的数组长度
        int oldCapacity = elementData.length;
        // 新的数组长度 = 旧的数组长度 + 旧的数组长度向右移1位。位运算符速度执行快
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 1. 新的长度小于需要指定最小的长度, 则使用指定最小的长度
        // 2. 或者oldCpacity=2136372536, oldCapacity + (oldCapacity >> 1)=-1090408492, 位运算向右移后再相加, 导致超出32位舍弃最高度, 刚好导致最高位为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);
    }   
	private static int hugeCapacity(int minCapacity) {
		// 如果数组的长度为int最大值2147483647, +1后会超过32位最大值丢弃最高位变为负数-2147483648
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

4. 指定位置添加元素add(int index, E element)，list长度很大时尽量少使用，每次添加都会导致数组复制效率很低

    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

5. List list = new ArrayList<>(Arrays.asList(1,2,3,1,2,1,3,1,1,2,2,2,2,3,3,3)); 怎么删除List中所有为1的数据？

	// 正确代码，使用迭代器删除
    List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,1,2,1,3,1,1,2,2,2,2,3,3,3));
    Iterator<Integer> iterator = list.iterator();
    while (iterator.hasNext()) {
        Integer next = iterator.next();
        if (next == 1) {
            iterator.remove();
        }
    }
    // 错误代码1, 输出结果为[2, 3, 2, 3, 1, 2, 2, 2, 2, 3, 3, 3]
    List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,1,2,1,3,1,1,2,2,2,2,3,3,3));
    for (int i = 0; i < list.size(); i++) {
        if (list.get(i) == 1) {
            list.remove(i);
        }
    }
    // 错误代码2, 输出结果抛出异常java.util.ConcurrentModificationException, for循环在编译后会转换成iterator。
    List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,1,2,1,3,1,1,2,2,2,2,3,3,3));
    for (Integer i: list) {
        if (i == 1) {
        	// 
            list.remove(i);
        }
    }
    // list.remove的代码
    public E remove(int index) {
        rangeCheck(index);
		// 这里只修改了modCount, 没有修改迭代器中的变量expectedModCount, 在调用迭代器的方法next()时会抛出异常
        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }
    /****************************************   ****************************************/
    // 在ArrayList的迭代器中next()方法会校验修改数据的次数
    public E next() {
       checkForComodification();
       int i = cursor;
       if (i >= size)
           throw new NoSuchElementException();
       Object[] elementData = ArrayList.this.elementData;
       if (i >= elementData.length)
           throw new ConcurrentModificationException();
       cursor = i + 1;
       return (E) elementData[lastRet = i];
   }
   final void checkForComodification() {
   	// 如果使用了迭代器遍历, 但是没用使用迭代器的remove()方法删除元素, 会导致两个变量不相等抛出异常
   	if (modCount != expectedModCount)
           throw new ConcurrentModificationException();
   }
   public void remove() {
       if (lastRet < 0)
           throw new IllegalStateException();
       checkForComodification();

       try {
           ArrayList.this.remove(lastRet);
           cursor = lastRet;
           lastRet = -1;
           // 迭代器的remove方法对expectedModCount重新复制
           expectedModCount = modCount;
       } catch (IndexOutOfBoundsException ex) {
           throw new ConcurrentModificationException();
       }
   }

二、Collections.synchronizedList

1. 使用方法 List list = Collections.synchronizedList(new ArrayList()); 且该方法返回的是一个方法都加锁的对象SynchronizedList
2. 多线程下使用for循环遍历，或者迭代器遍历必须手动加锁。

	// 锁对象为自身
    SynchronizedCollection(Collection<E> c) {
        this.c = Objects.requireNonNull(c);
        mutex = this;
    }
	// 锁对象为mutex
    SynchronizedCollection(Collection<E> c, Object mutex) {
        this.c = Objects.requireNonNull(c);
        this.mutex = Objects.requireNonNull(mutex);
    }
    public int size() {
        synchronized (mutex) {return c.size();}
    }
	// 源码中没有加锁必须手动加锁
    public Iterator<E> iterator() {
        return c.iterator(); // Must be manually synched by user!
    }
    public boolean add(E e) {
        synchronized (mutex) {return c.add(e);}
    }
    public boolean remove(Object o) {
        synchronized (mutex) {return c.remove(o);}
    }

3. 同时操作add和contains方法时，两个单独的方法虽然是线程安全的。但是两个方法同时调用却不是原子性操作，也需要加锁

	List list = Collections.synchronizedList(new ArrayList<>());
	// 多线程往list中添加数据
	for (int i = 0; i < 50; i++) {
	    Thread thread = new Thread(new Runnable() {
	        @Override
	        public void run() {
	            synchronized (list) {
	                if (!list.contains(1)) {
	                    list.add(1);
	                } 
	            }
	        }
	    });
	    thread.start();
	}

三、CopyOnWriteArrayList

1. 对CopyOnWriteArrayList进行修改，会先拷贝一个新数组然后在其上进行操作。修改后的内容其他线程不会及时看到，只能等修改操作完成后才看到。所以如果业务需要看到及时的数据CopyOnWriteArrayList是适用这个业务的。而且每次修改都会有拷贝数组的操作，所以也不适用有大量修改的业务。
2. 因为修改操作是在新数组上进行，对原数组不会影响。所以读取方法不需要加锁，读取操作性能很快。CopyOnWriteArrayList适用读取操作多，修改操作少的业务。
3. 多线程下使用for循环遍历，不需要手动加锁，因为遍历时，即使有线程修改也是修改复制的新数组

	// 读取方法
    public E get(int index) {
        return get(getArray(), index);
    }
    // 添加方法
    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        // 加锁
        lock.lock();
        try {
        	// 旧数组
            Object[] elements = getArray();
            int len = elements.length;
            // 将旧数组的值复制到新数组上
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            // 新数组添加元素
            newElements[len] = e;
            // list的数据列表替换为新数组
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

参考内容

1. https://www.jianshu.com/p/0b3e5df6fe57