JUC 高并发编程之集合的线程安全

JUC 高并发编程之集合的线程安全

集合操作 Demo

NotSafeDemo

• import java.util.ArrayList;
  import java.util.List;
  import java.util.UUID;
  /**
  * 集合线程安全案例
  */
  public class NotSafeDemo {
  /**
  * 多个线程同时对集合进行修改
  * @param args
  */
  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 类型的线程安全问题?

Vector

• Vector 是矢量队列，它是 JDK1.0 版本添加的类。继承于 AbstractList，实现了 List, RandomAccess, Cloneable 这些接口。 Vector 继承了 AbstractList，实现了 List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。 Vector 实现了 RandmoAccess 接口，即提供了随机访问功能
• RandmoAccess 是 java 中用来被 List 实现，为 List 提供快速访问功能的。在Vector 中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访 问。 Vector 实现了 Cloneable 接口，即实现 clone()函数。它能被克隆

Vector 中的操作是线程安全的

NotSafeDemo 代码修改

• import java.util.ArrayList;
  import java.util.List;
  import java.util.UUID;
  import java.util.Vector;
  
  /**
  * 集合线程安全案例
  */
  public class NotSafeDemo {
  /**
  * 多个线程同时对集合进行修改
  * @param args
  */
  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();
  } } }
  

• 现在没有运行出现并发异常,为什么?

• /**
  * 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 同步修辞,线程安全!因此没有并发异常

Collections

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

• NotSafeDemo 代码修改

• import java.util.*;
  /**
  * 集合线程安全案例
  */
  
  public class NotSafeDemo {
  /**
  * 多个线程同时对集合进行修改
  * @param args
  */
  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));
  }
  

CopyOnWriteArrayList

• 它相当于线程安全的 ArrayList。和 ArrayList 一样，它是个可变数组；但是和ArrayList 不同的时，它具有以下特性：

  • 它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突
  • 它是线程安全的
  • 因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大
  • 迭代器支持 hasNext(), next()等不可变操作，但不支持可变 remove()等操作
  • 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照

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

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

• 复制思想：

  • 当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行 Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器
  • 这时候会抛出来一个新的问题，也就是数据不一致的问题。如果写线程还没来得及写会内存，其他的线程就会读到了脏数据

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

• NotSafeDemo 代码修改

• import java.util.*;
  import java.util.concurrent.CopyOnWriteArrayList;
  
  /**
  * 集合线程安全案例
  */
  public class NotSafeDemo {
  
  /**
  * 多个线程同时对集合进行修改
  * @param args
  */
  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();
  } } }
  

• 没有线程安全问题

CopyOnWriteArrayList 的原理

• 动态数组机制
• 它内部有个“volatile 数组”(array)来保持数据。在“添加/修改/删除”数据时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该数组赋值给“volatile 数组”, 这就是它叫做 CopyOnWriteArrayList 的原因
• 由于它在“添加/修改/删除”数据时，都会新建数组，所以涉及到修改数据的操作，CopyOnWriteArrayList 效率很低；但是单单只是进行遍历查找的话，效率比较高
• 线程安全机制
• 通过 volatile 和互斥锁来实现的
• 通过“volatile 数组”来保存数据的。一个线程读取 volatile 数组时，总能看到其它线程对该 volatile 变量最后的写入；就这样，通过 volatile 提供了“读取到的数据总是最新的”这个机制的保证
• 通过互斥锁来保护数据。在“添加/修改/删除”数据时，会先“获取互斥锁”，再修改完毕之后，先将数据更新到“volatile 数组”中，然后再“释放互斥锁”，就达到了保护数据的目的

小结

• 线程安全与线程不安全集合

  • 集合类型中存在线程安全与线程不安全的两种,常见例如:
  • ArrayList ----- Vector
  • HashMap -----HashTable
  • 但是以上都是通过 synchronized 关键字实现,效率较低

• Collections 构建的线程安全集合

• .java.util.concurrent 并发包下

  • CopyOnWriteArrayList CopyOnWriteArraySet 类型,通过动态数组与线程安全个方面保证线程安全