1. 集合操作Demo

NotSafeDemo

package com.atguigu.test;
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 类型的线程安全问题?==

2. Vector

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

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 方法

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

3. Collections

Collections 提供了方法 synchronizedList 保证 list 是同步线程安全的
NotSafeDemo 代码修改

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();
        }
    }
}

没有并发修改异常
查看方法源码

/**
* 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. CopyOnWriteArrayList(重点)

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

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

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

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();
        }
    }
}

没有线程安全问题
原因分析(重点):==动态数组与线程安全==
下面从“动态数组” 和“线程安全” 两个方面进一步对CopyOnWriteArrayList 的原理进行说明。

动态数组” 机制
- 它内部有个“volatile 数组”(array)来保持数据。在“添加/修改/删除” 数据时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该数组赋值给“volatile 数组”, 这就是它叫做 CopyOnWriteArrayList 的原因
- 由于它在“添加/修改/删除” 数据时，都会新建数组，所以涉及到修改数据的操作， CopyOnWriteArrayList 效率很低；但是单单只是进行遍历查找的话，效率比较高。
线程安全” 机制
- 通过 volatile 和互斥锁来实现的。
- 通过“volatile 数组” 来保存数据的。一个线程读取 volatile 数组时，总能看到其它线程对该 volatile 变量最后的写入；就这样，通过 volatile 提供了“读取到的数据总是最新的” 这个机制的保证。
- 通过互斥锁来保护数据。在“添加/修改/删除” 数据时，会先“获取互斥锁” ，再修改完毕之后，先将数据更新到“volatile 数组” 中，然后再“释放互斥锁” ，就达到了保护数据的目的。
  5. 小结(重点)
  1.线程安全与线程不安全集合
  集合类型中存在线程安全与线程不安全的两种,常见例如:
  ArrayList ——- Vector
  HashMap ——-HashTable
  但是以上都是通过 synchronized 关键字实现,效率较低
  2.Collections 构建的线程安全集合
  3.java.util.concurrent 并发包下
  CopyOnWriteArrayList CopyOnWriteArraySet 类型,通过动态数组与线程安
  全个方面保证线程安全

Java 后端

第四章集合的线程安全

1. 集合操作Demo

2. Vector

3. Collections

4. CopyOnWriteArrayList(重点)

5. 小结(重点)

第四章 集合的线程安全

1. 集合操作Demo

2. Vector

3. Collections

4. CopyOnWriteArrayList(重点)

5. 小结(重点)

第四章集合的线程安全