java集合类不安全问题
集合类不安全之并发修改异常
ArrayList
ArrayList的底层数据结构就是一个数组，数组元素的类型为Object类型，对ArrayList的所有操作底层都是基于数组的。
为了提高并发效率，add方法没有添加synchronized，也没有其他任何保证线程安全的方法。所以是线程不安全的。
package com.collection;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
public class Test01 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
//30个线程同时写操作
for(int i = 1; i<=30; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(list);
},String.valueOf(i)).start();
}
}
}
分析和解决
故障现象
java.util.ConcurrentModificationException
导致原因
并发争抢修改导致
例如：一个人在写入，另外一个人过来抢夺，导致数据不一致异常。就是并发修改异常。
解决方案
new Vector<>();
Vector的add方法添加了synchronized，所以大大降低了并发效率。
package com.collection;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.Vector;
public class Test01 {
public static void main(String[] args) {
List<String> list = new Vector<>();
//30个线程同时写操作
for(int i = 1; i<=30; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(list);
},String.valueOf(i)).start();
}
}
}
Collections.synchronizedList(new ArrayList<>());
使用Collections工具类
package com.collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import java.util.Vector;
public class Test01 {
public static void main(String[] args) {
List<String> list = Collections.synchronizedList(new ArrayList<>());
//30个线程同时写操作
for(int i = 1; i<=30; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(list);
},String.valueOf(i)).start();
}
}
}
new CopyOnWriteArrayList<>();
使用写时复制ArrayList
package com.collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import java.util.Vector;
import java.util.concurrent.CopyOnWriteArrayList;
public class Test01 {
public static void main(String[] args) {
List<String> list = new CopyOnWriteArrayList<>();
//30个线程同时写操作
for(int i = 1; i<=30; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(list);
},String.valueOf(i)).start();
}
}
}
集合类不安全之写时复制
在并发的运行环境重要的核心变量都加上了volatile
CopyOnWriteArrayList.add原码
lock加锁是为了不受其他干扰。
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return {@code true} (as specified by {@link Collection#add})
*/
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();
}
}
CopyOnWrite容器即写时复制的容器。往一个容器添加元素的时候，不直接往当前容器Object[]添加，而是先将当前容器Object[]进行copy，复制出一个新的容器Object[] newElements，然后新的容器Object[] newElements里添加元素，添加完元素之后，再将原容器的引用指向新的容器setArray(newElements)；这样做的好处是可以对copyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。
集合类不安全之Set
HashSet
package com.collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.Vector;
import java.util.concurrent.CopyOnWriteArrayList;
public class Test01 {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
//30个线程同时写操作
for(int i = 1; i<=30; i++) {
new Thread(() -> {
set.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(set);
},String.valueOf(i)).start();
}
}
}
一样出现java.util.ConcurrentModificationException
分析和解决
故障现象
java.util.ConcurrentModificationException
导致原因
并发争抢修改导致
例如：一个人在写入，另外一个人过来抢夺，导致数据不一致异常。就是并发修改异常。
解决方案
Collections.synchronizedSet(new HashSet<>());
使用Collections工具类
package com.collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.Vector;
import java.util.concurrent.CopyOnWriteArrayList;
public class Test01 {
public static void main(String[] args) {
Set<String> set = Collections.synchronizedSet(new HashSet<>());
//30个线程同时写操作
for(int i = 1; i<=30; i++) {
new Thread(() -> {
set.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(set);
},String.valueOf(i)).start();
}
}
}
new CopyOnWriteArraySet<>();
package com.collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.Vector;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
public class Test01 {
public static void main(String[] args) {
Set<String> set = new CopyOnWriteArraySet<>();
//30个线程同时写操作
for(int i = 1; i<=30; i++) {
new Thread(() -> {
set.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(set);
},String.valueOf(i)).start();
}
}
}
实质是还是一个CopyOnWriteArrayList
集合类不安全之Map
HashMap
HashMap基于Map接口实现，元素以键值对的方式存储，并且允许使用null 建和null值，因为key不允许重复，因此只能有一个键为null,另外HashMap不能保证放入元素的顺序，它是无序的，和放入的顺序并不能相同。HashMap是线程不安全的。
package com.collection;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;
public class Test01 {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
//30个线程同时写操作
for(int i = 1; i<=30; i++) {
new Thread(() -> {
map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0, 8));
System.out.println(map);
},String.valueOf(i)).start();
}
}
}
分析和解决
故障现象
java.util.ConcurrentModificationException
导致原因
并发争抢修改导致
例如：一个人在写入，另外一个人过来抢夺，导致数据不一致异常。就是并发修改异常。
解决方案
Collections.synchronizedMap(new HashMap<>());
Collections工具类可以解决
package com.collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
public class Test01 {
public static void main(String[] args) {
Map<String,String> map = Collections.synchronizedMap(new HashMap<>());
//30个线程同时写操作
for(int i = 1; i<=30; i++) {
new Thread(() -> {
map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0, 8));
System.out.println(map);
},String.valueOf(i)).start();
}
}
}
new ConcurrentHashMap<>();
package com.collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
public class Test01 {
public static void main(String[] args) {
Map<String,String> map = new ConcurrentHashMap<>();
//30个线程同时写操作
for(int i = 1; i<=30; i++) {
new Thread(() -> {
map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0, 8));
System.out.println(map);
},String.valueOf(i)).start();
}
}
}
