- List集合线程不安全操作
- Vector
- List集合线程安全案例1
- Collections
- List集合线程安全案例2
- CopyonWriteArrayList(重点)
- CopyOnWriteArrayList的思想和原理
- List集合线程安全案例3
- 没有线程安全问题原因分析(重点):
- 集合案例DEMO
- 小结(重点)
集合线程不安全案例
package com.atguigu.test;
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 方法源码
public boolean add(E e) {
ensureCapacityInternal(size + 1);
// Increments modCount!! elementData[size++] = e;
return true;
}
那么我们如何去解决 List 类型的线程安全问题?
VectorVector 是矢量队列，它是 JDK1.0 版本添加的类。
- 继承于 AbstractList，实现了 List, RandomAccess, Cloneable 这些接口。
- Vector 继承了 AbstractList， 实现了 List;所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。
- Vector 实现了 RandmoAccess 接口，即提供了随机访问功能。
- RandmoAccess 是 java 中用来被 List 实现，为 List 提供快速访问功能的。
- 在 Vector 中，我们即可以通过元素的序号快速获取元素对象;这就是快速随机访问。
Vector 实现了 Cloneable 接口，即实现 clone()函数。它能被克隆。 - 和 ArrayList 不同，Vector 中的操作是线程安全的。
NotSafeDemo 代码修改
package com.atguigu.test;
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 方法
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
add 方法被 synchronized 同步修辞,线程安全!
因此没有并发异常
Collections 提供了方法 synchronizedList
保证 list 是同步线程安全的
NotSafeDemo 代码修改
package com.atguigu.test;
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();
}
}
}
没有并发修改异常
查看方法源码
public staticCopyonWriteArrayList(重点)List synchronizedList(List 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 代码修改
package com.atguigu.test;
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();
}
}
}
没有线程安全问题原因分析(重点):
动态数组与线程安全
下面从“动态数组”和“线程安全”两个方面进一步对 CopyonWriteArrayList 的原理进行说明。
-
“动态数组”机制
- 它内部有个“volatile 数组”(array)来保持数据。在“添加/修改/删除”数据时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该数组赋值给“volatile 数组”, 这就是它叫做 CopyonWriteArrayList 的原因
- 由于它在“添加/修改/删除”数据时，都会新建数组，所以涉及到修改数据的操作，
- CopyonWriteArrayList 效率很低;但是单单只是进行遍历查找的话， 效率比较高。
-
“线程安全”机制
- 通过 volatile 和互斥锁来实现的。
- 通过“volatile 数组”来保存数据的。一个线程读取 volatile 数组时，总能看到其它线程对该 volatile 变量最后的写入;就这样，通过 volatile 提供了“读取到的数据总是最新的”这个机制的保证。
- 通过互斥锁来保护数据。在“添加/修改/删除”数据时，会先“获取互斥锁”，再修改完毕之后，先将数据更新到“volatile 数组”中，然后再“释放互斥 锁”，就达到了保护数据的目的。
package com.java.juc.lock;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
public class ThreadDemo4 {
public static void main(String[] args) {
//list集合线程不安全
//listDemo();
//HashSet集合线程不安全 演示
//setDemo();
//Map map = new HashMap<>();
Map map = new ConcurrentHashMap<>();
for(int i=0;i<30;i++){
String key = String.valueOf(i);
new Thread(()->{
//向集合中增加内容
map.put(key,UUID.randomUUID().toString().substring(0,8));
//从集合中获取内容
System.out.println(map);
},"线程：" + key).start();
}
}
private static void setDemo(){
//Set set = new HashSet<>();
Set set = new CopyOnWriteArraySet<>();
for(int i=0;i<30;i++){
new Thread(()->{
//向集合中增加内容
set.add(UUID.randomUUID().toString().substring(0,8));
//从集合中获取内容
System.out.println(set);
},"线程："+ String.valueOf(i)).start();
}
}
private static void listDemo(){
// List list = new ArrayList();
// List list = new Vector<>();
//List list = Collections.synchronizedList(new ArrayList<>());
List list = new CopyOnWriteArrayList<>();
for(int i=0;i<10;i++){
new Thread(()->{
//向集合中增加内容
list.add(UUID.randomUUID().toString().substring(0,8));
//从集合中获取内容
System.out.println(list);
},"线程："+ String.valueOf(i)).start();
}
}
}
小结(重点)
- 线程安全与线程不安全集合
集合类型中存在线程安全与线程不安全的两种, 常见例如: ArrayList ----- Vector HashMap -----HashTable 但是以上都是通过 synchronized 关键字实现,效率较低
- Collections 构建的线程安全集合
List: Collections.synchronizedList(new ArrayList<>()); Set: Collections.synchronizedSet(new HashSet<>());
- java.util.concurrent 并发包下
CopyOnWriteArrayList、CopyonWriteArraySet 类型,通过动态数组与线程安全个方面保证线程安全 List: CopyonWriteArrayList Set: CopyonWriteArraySet Map: ConcurrentHashMap
