瞄一眼CopyOnWriteArrayList（jdk11）

CopyOnWriteArrayList是ArrayList线程安全的变体。使用写时复制策略进行修改操作。

与之前版本较明显的区别是，jdk11中用来保护所有设值方法(mutator)的ReentrantLock改为使用关键字synchronized。

文档中也明确表示相比较于ReentrantLock更倾向于使用内置锁(We have a mild preference for builtin monitors over ReentrantLock when either will do.)。

两个都是可重入独占锁，在不涉及到中断、超时等情况时，编码时使用synchronized明显比ReentrantLock优势得多。

CopyOnWriteArrayList的成员变量：

    //锁对象
    final transient Object lock = new Object();

    //存储数据的数组
    private transient volatile Object[] array;

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

    final void setArray(Object[] a) {
        array = a;
    }

第一个Object对象充当写时复制的锁对象，第二个volatile的array用来存放数据

挑个构造函数看看：

    /**
     * 根据Collection迭代器返回的顺序创建包含指定集合元素的列表
     *
     * @param c 最初保存元素的集合
     * @throws NullPointerException 如果指定的集合为null
     */
    public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] es;
        if (c.getClass() == CopyOnWriteArrayList.class)
            es = ((CopyOnWriteArrayList<?>)c).getArray();    //同类对象直接获取array赋值
        else {
            es = c.toArray();
            // defend against c.toArray (incorrectly) not returning Object[]
            // (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652)
            if (es.getClass() != Object[].class)
                es = Arrays.copyOf(es, es.length, Object[].class);
        }
        setArray(es);    //array赋值
    }

注释中说，L15的条件分支是为了解决Collection.toArray()没有正确地返回为Object[]类型，而是错误地返回为Object类型。这个bug在jdk9已经被修复了。不知道为什么在11.0.2还留着。

jdk中的//单行注释一般都挺有意思的…

读操作和ArrayList没多大差别，所以都是弱一致性的。挑几个写操作看看：

  public void add(int index, E element) {
    synchronized (lock) { //获取独占锁
      Object[] es = getArray();
      int len = es.length;
      if (index > len || index < 0) { //越界校验
        throw new IndexOutOfBoundsException(outOfBounds(index, len));
      }
      Object[] newElements;
      int numMoved = len - index;
      if (numMoved == 0) {  //若index=array.length,则新元素添加在末尾
        newElements = Arrays.copyOf(es, len + 1);
      } else {
        newElements = new Object[len + 1];    //创建array副本,调用System.arraycopy()移动index后元素添加新元素于index
        System.arraycopy(es, 0, newElements, 0, index);
        System.arraycopy(es, index, newElements, index + 1, numMoved);
      }
      newElements[index] = element;
      setArray(newElements);    //将修改后的array副本回写给array
    }
  }

  public E set(int index, E element) {
    synchronized (lock) { //获取独占锁
      Object[] es = getArray();
      E oldValue = elementAt(es, index);  //找出index位置的元素
      if (oldValue != element) {    //如果元素与原先元素不同,则创建array副本。在副本修改后写回array
        es = es.clone();
        es[index] = element;
        setArray(es);
      }
      return oldValue;
    }
  }

值得注意的是，之前版本的set方法在上段代码L9多了个分支：

} else {
      // Not quite a no-op; ensures volatile write semantics
      setArray(elements);
}

注释说了，setArray()是为了保持volatile写的语义，即内存一致性：当存在并发时，将对象放入CopyOnWriteArrayList之前的线程中的操作happen-before随后通过另一线程从CopyOnWriteArrayList中访问或移除该元素的操作。由于jdk11使用synchronized替代了ReentrantLock，也就不需要这一段了。