4 集合的线程安全

4.1 集合操作 Demo（演示）

NotSafeDemo：

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
/*** 集合线程安全案例
*/
public class NotSafeDemo {
/**
* 多个线程同时对集合进行修改
*/
    public static void main(String[] args) {
        List list = new ArrayList();
        for (int i = 0; i < 100; i++) {
           new Thread(() ->{
             list.add(UUID.randomUUID().toString());
             System.out.println(list);
         }, "线程" + i).start();
       }
   }
}

结果：异常内容
java.util.ConcurrentModificationException

问题: 为什么会出现并发修改异常?
查看 ArrayList 的 add 方法源码

/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
   ensureCapacityInternal(size + 1); // Increments modCount!!
   elementData[size++] = e;
   return true;
}

那么我们如何去解决 List 类型的线程安全问题?

4.2 Vector

Vector 是矢量队列，它是 JDK1.0 版本添加的类。继承于 AbstractList，实现了 List, RandomAccess, Cloneable 这些接口。 Vector 继承了 AbstractList，实现了 List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。 Vector 实现了 RandmoAccess 接口，即提供了随机访问功能。

RandmoAccess 是 java 中用来被 List 实现，为 List 提供快速访问功能的。在Vector 中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。 Vector 实现了 Cloneable 接口，即实现 clone()函数。它能被克隆。

和 ArrayList 不同，Vector 中的操作是线程安全的。

NotSafeDemo 代码修改:

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.Vector;
/**
* 集合线程安全案例
*/
public class NotSafeDemo {
/**
* 多个线程同时对集合进行修改
*/
  public static void main(String[] args) {
      List list = new Vector();
      for (int i = 0; i < 100; i++) {
          new Thread(() ->{
            list.add(UUID.randomUUID().toString());System.out.println(list);
          }, "线程" + i).start();
      }
   }
}

结果没有出现异常。

查看 Vector 的 add 方法

/**
* Appends the specified element to the end of this Vector.
*
* @param e element to be appended to this Vector
* @return {@code true} (as specified by {@link Collection#add})
* @since 1.2
*/
public synchronized boolean add(E e) {
   modCount++;
   ensureCapacityHelper(elementCount + 1);
   elementData[elementCount++] = e;
   return true;
 }

发现了add 方法被 synchronized 同步修辞,线程安全!因此没有并发异常。

4.3 Collections

Collections 提供了方法 synchronizedList 保证 list 是同步线程安全的。

NotSafeDemo 代码修改

import java.util.*;
/**
* 集合线程安全案例
*/public class NotSafeDemo {
/**
* 多个线程同时对集合进行修改
*/
   public static void main(String[] args) {
       List list = Collections.synchronizedList(new ArrayList<>());
       for (int i = 0; i < 100; i++) {
           new Thread(() ->{
               list.add(UUID.randomUUID().toString());
               System.out.println(list);
           }, "线程" + i).start();
      }
   }
}

结果也没有出现异常。

查看方法源码

/**
* Returns a synchronized (thread-safe) list backed by the specified
* list. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing list is accomplished
* through the returned list.<p>
*
* It is imperative that the user manually synchronize on the returned
* list when iterating over it:
* <pre>
* List list = Collections.synchronizedList(new ArrayList());
* ...
* synchronized (list) {
* Iterator i = list.iterator(); // Must be in synchronized block
* while (i.hasNext())
* foo(i.next());
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.*
* <p>The returned list will be serializable if the specified list is
* serializable.
*
* @param <T> the class of the objects in the list
* @param list the list to be "wrapped" in a synchronized list.
* @return a synchronized view of the specified list.
*/
public static <T> List<T> synchronizedList(List<T> list) {
    return (list instanceof RandomAccess ?
    new SynchronizedRandomAccessList<>(list) :
    new SynchronizedList<>(list));
}

4.4 CopyOnWriteArrayList(重点)

首先我们对 CopyOnWriteArrayList 进行学习,其特点如下:
它相当于线程安全的 ArrayList。和 ArrayList 一样，它是个可变数组；但是和ArrayList 不同的时，它具有以下特性：

1. 它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突。

2. 它是线程安全的。

3. 因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大。

4. 迭代器支持 hasNext(), next()等不可变操作，但不支持可变 remove()等操作。

5. 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。

6. 独占锁效率低：采用读写分离思想解决

7. 写线程获取到锁，其他写线程阻塞

8. 复制思想：

当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行 Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。

这时候会抛出来一个新的问题，也就是数据不一致的问题。如果写线程还没来得及写进内存，其他的线程就会读到了脏数据。

这就是 CopyOnWriteArrayList 的思想和原理。就是拷贝一份。

NotSafeDemo 代码修改

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* 集合线程安全案例
*/
public class NotSafeDemo {
/**
* 多个线程同时对集合进行修改
*/
    public static void main(String[] args) {
       List list = new CopyOnWriteArrayList();
       for (int i = 0; i < 100; i++) {
           new Thread(() ->{
                list.add(UUID.randomUUID().toString());
                System.out.println(list);
            }, "线程" + i).start();
       }
    }
}

结果还是没有问题。

**原因分析(重点)