集合操作Demo

不安全Demo

package com.atguigu.test;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
/**
* 集合线程安全案例
*/
public class NotSafeDemo {
    /**
* 多个线程对集合添加内容（UUID.randomUUID()），并打印出来
* @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().substring(0,7));
                System.out.println(list);
            }
            , "线程" + i).start();
        }
    }
}
================================
出现并发修改异常：java.util.ConcurrentModificationException

为什么出现异常

一个线程正在写，另一个线程过来抢占资源，会造成数据不一致，进而报并发修改异常。
查看ArrayList的add方法源码：1.先确保还可以增1；2.再把元素加入到elementDate数组中

/**
* 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;
}

解决方案1：Vector

用的不多，因为年代久远

Vector 是矢量队列，它是 JDK1.0 版本添加的类。继承于 AbstractList，实现了 List, RandomAccess, Cloneable 这些接口。所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。
Vector 实现了 RandmoAccess 接口，即提供了随机访问功能。 RandmoAccess 是 java 中用来被 List 实现，为 List 提供快速访问功能的。在 Vector 中，我们即可以通过元素的序号快速获取元素对象。
Vector 实现了 Cloneable 接口，即实现 clone()函数。它能被克隆。
和 ArrayList 不同，Vector 中的操作是线程安全的。
使用Vector修改后的Demo
```java package com.atguigu.test; 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();
  }

} } ```

异常解除分析

查看 Vector 的 add 方法 : add 方法被 synchronized 同步修饰,线程安全!因此没有并发异常
```java /**

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; } ```
解决方案2：Collections
用的不多，年代久远
Collections 提供了方法 synchronizedList 保证 list 是同步线程安全的
```java package com.atguigu.test; 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();
```
} } } ```
异常解除分析
```java /**
Returns a synchronized (thread-safe) list backed by the specified
list. In order to guarantee serial access, it is critical that
all access to the backing list is accomplished
through the returned list.
*
It is imperative that the user manually synchronize on the returned
list when iterating over it:
List list = Collections.synchronizedList(new ArrayList());
…
synchronized (list) {
Iterator i = list.iterator(); // Must be in synchronized block
while (i.hasNext())
foo(i.next());
}
Failure to follow this advice may result in non-deterministic behavior *
The returned list will be serializable if the specified list is
serializable. *
@param 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
List
synchronizedList(List
list) { return (list instanceof RandomAccess ? new SynchronizedRandomAccessList<>(list) : new SynchronizedList<>(list)); }
```
<a name="oqf6r"></a>
## 解决方案3：CopyOnWriteArrayList（重点）
兼顾了并发读和独立写。新建数组复制的集合中元素，再写入新的内容，再还原成新集合。成为新的集合供用户下次的并发读<br />CopyOnWriteArrayList源码中的add()：
```java
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 {
          lock.unlock();
      }
```
读写分离思想：因为独占锁效率低所以CopyOnWriteArrayList采用读写分离思想解决，写线程获取到锁，其他写线程阻塞
复制思想：当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行 Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。
```java package com.atguigu.test; 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();
  }
```
} } ``` 它相当于线程安全的 ArrayList。和 ArrayList 一样，它是个可变数组；但是和 ArrayList 不同的时，它具有以下特性：
1. 它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突。
2. 它是线程安全的。
3. 因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大。
4. 迭代器支持 hasNext(), next()等不可变操作，但不支持可变 remove()等操作。
5. 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。
异常解除分析

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

小结

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

集合类型中存在线程安全与线程不安全的两种
常见例如: ArrayList ——- Vector ； HashMap ——-HashTable
但是以上都是通过 synchronized 关键字实现,效率较低
Collections 构建的线程安全集合
java.util.concurrent 并发包下
1. CopyOnWriteArrayList CopyOnWriteArraySet 类型,通过动态数组与线程安全个方面保证线程安全

CS笔记

5、集合的线程安全

集合操作Demo

不安全Demo

为什么出现异常

解决方案1：Vector

使用Vector修改后的Demo

异常解除分析

解决方案2：Collections

异常解除分析

异常解除分析

HashSet线程不安全

解决方案：CopyOnWriteArraySet

HashMap线程不安全

解决方案：ConcurrentHashMap

小结