Java并发中集合容器之CopyOnWriteArrayList、Vector

最常用的ArrayList和LinkedList都是线程不安全的。

在多线程环境中，当一个集合在遍历时，集合内数据被修改（增删操作），迭代器会抛出异常java.util.ConcurrentModificationException，所以我们一般要使用线程安全的容器去存储数据。

• 1、Vector类
  Vector是List接口中的一个实现类，是线程安全的，每个方法都有synchronized修饰，所以每个方法执行时都要进行同步，效率比较低。

• 2、CopyOnWriteArrayList类
  是JUC包中在JDK1.5后引入的集合类，是线程安全的。
  这个线程安全的集合实际上用的是数组的拷贝，然后对新数组里的数据进行操作的。

  我们来看一下这个集合中方法的源码

      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;
              setArray(newElements); //数组的引用重新指向复制的数组
              return true;
          } finally { //finally代码块中解锁，否则发生异常的话就无法解锁
              lock.unlock(); 
          }
      }
      
      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)
                  setArray(Arrays.copyOf(elements, len - 1));
              else {
                  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();
          }
      }
  
      public void clear() {
          final ReentrantLock lock = this.lock;
          lock.lock();
          try {
              setArray(new Object[0]);
          } finally {
              lock.unlock();
          }
      }
  
      public E get(int index) { //无锁
          return get(getArray(), index);
      }
  
      public int size() { //无锁
          return getArray().length;
      }
  

  这个类中的增删方法都有用锁，而get()方法没有上锁
  总结：这个类在执行写操作时，给集合对象上锁，复制一份新数组，然后对新数组进行操作，然后把数组的引用指向这个新数组。但是在对这个集合进行读操作时没有上锁。所以CopyOnWriteArrayList比Vector的性能要好。

• 3、Collections.synchronizedList()

Collections是集合工具类，synchronizedList是一个静态方法，可以返回线程安全的集合，但是若想迭代这个返回的集合，还需要手动同步，代码如下：

List list = Collections.synchronizedList(new ArrayList());
      ...
  synchronized (list) {
      Iterator i = list.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }

让我们看看Collections.synchronizedList的源码，每个方法中都有synchronized代码块，除了listIterator()方法

/**
     * @serial include
     */
    static class SynchronizedList<E>
        extends SynchronizedCollection<E>
        implements List<E> {
        private static final long serialVersionUID = -7754090372962971524L;

        final List<E> list;

        SynchronizedList(List<E> list) {
            super(list);
            this.list = list;
        }
        SynchronizedList(List<E> list, Object mutex) {
            super(list, mutex);
            this.list = list;
        }

        public boolean equals(Object o) {
            if (this == o)
                return true;
            synchronized (mutex) {return list.equals(o);}
        }
        public int hashCode() {
            synchronized (mutex) {return list.hashCode();}
        }

        public E get(int index) {
            synchronized (mutex) {return list.get(index);}
        }
        public E set(int index, E element) {
            synchronized (mutex) {return list.set(index, element);}
        }
        public void add(int index, E element) {
            synchronized (mutex) {list.add(index, element);}
        }
        public E remove(int index) {
            synchronized (mutex) {return list.remove(index);}
        }

        public int indexOf(Object o) {
            synchronized (mutex) {return list.indexOf(o);}
        }
        public int lastIndexOf(Object o) {
            synchronized (mutex) {return list.lastIndexOf(o);}
        }

        public boolean addAll(int index, Collection<? extends E> c) {
            synchronized (mutex) {return list.addAll(index, c);}
        }
		//***********************主要是这个方法 注释：需要我们手动同步
        public ListIterator<E> listIterator() {
            return list.listIterator(); // Must be manually synched by user
        }

        public ListIterator<E> listIterator(int index) {
            return list.listIterator(index); // Must be manually synched by user
        }

        public List<E> subList(int fromIndex, int toIndex) {
            synchronized (mutex) {
                return new SynchronizedList<>(list.subList(fromIndex, toIndex),
                                            mutex);
            }
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            synchronized (mutex) {list.replaceAll(operator);}
        }
        @Override
        public void sort(Comparator<? super E> c) {
            synchronized (mutex) {list.sort(c);}
        }

        /**
         * SynchronizedRandomAccessList instances are serialized as
         * SynchronizedList instances to allow them to be deserialized
         * in pre-1.4 JREs (which do not have SynchronizedRandomAccessList).
         * This method inverts the transformation.  As a beneficial
         * side-effect, it also grafts the RandomAccess marker onto
         * SynchronizedList instances that were serialized in pre-1.4 JREs.
         *
         * Note: Unfortunately, SynchronizedRandomAccessList instances
         * serialized in 1.4.1 and deserialized in 1.4 will become
         * SynchronizedList instances, as this method was missing in 1.4.
         */
        private Object readResolve() {
            return (list instanceof RandomAccess
                    ? new SynchronizedRandomAccessList<>(list)
                    : this);
        }
    }