众所周知，ArrayList -> List -> Collection, ArrayList线程不安全。同理，Map, Set都是线程不安全。ArrayList总结起来就是: 初始化size为10的Object类型的数组。多并发修改值时可能: ConcurrentModificationException.
出现ConcurrentModificationException的ArrayList举例：30个线程同时对list进行add:
public static void main(String[] args) {
List<String> list = new ArrayList<>();
for (int i = 0; i < 30; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(list);
}, String.valueOf(i)).start();
}
}
各种exception:
- 同时对list读写:
ConcurrentModificationException. 解决办法:Vector,Collections.synchronizedList(new ArrayList<>()),CopyOnWriteArrayList -
IllegalMonitorStateException: 没有加lock/synchronized: 多线程争抢操作资源类 - java自带的
类.getClass().getClassLoader().**getParent()**...:NullPointerException; -
thread.start()调用多次:IllegalThreadStateException
ArrayList -> CopyOnWriteArrayList
HashSet -> CopyOnWriteArraySet
|
v
HashMap -> ConcurrentHashMap
- ArrayList: default cap: 10; grow strategy:
newCap= = oldCap + (oldCap >> 1): 15, 22... - HashMap: default cap: 16; grow strategy:
newCap = oldCap << 1; 是2^n;
ArrayList扩容中，new/old交替赋值元素用的方法是Arrays.copyOf:
elementData = Arrays.copyOf(elementData, newCapacity);
如何用线程安全的ArrayList?
Vector. 但是，不好👎，因为这是JDK 1.0的, 加了synchronized并发性下降。实际上ArrayList是JDK 1.2的(Doug Lea)，就是为了解决并发性能低才有的这个类.
怎么办?
Collections是工具类：Collections.synchronizedList(new ArrayList<>()).可以点进去看源码, 和ArrayList的add方法的区别就是, 方法前面有没有synchronized修饰.
还有更吊的: java.util.concurrent包中的类: CopyOnWriteArrayList, 写时复制。也是线程安全的.
为什么? 点进去:
public CopyOnWriteArrayList() {
setArray(new Object[0]);
}
点进去:
final void setArray(Object[] a) {
array = a;
}
点进去:
/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;
add方法
/**
* 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; // only 1 write/read happens at a time
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1); // add just 1 element
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
可以看出来, CopyOnWrite这种写时复制的容器，不是直接往那个容器添加元素，而是将当前的容器elements进行copy得到一个新的容器newElements,然后往新的容器中写。写完之后，把指向原来容器的引用指向新的容器setArray(newElements), 这样在写的时候并不影响从之前的容器中读, i.e. 可以对CopyOnWrite容器进行并发的读，这个读不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite是一种读写分离的思想，读写分离的容器。
当然，这种Arrays.copyOf过于频繁也不好，这种就看场景，如果是读多写少的场景, e.g. 跟mysql那种类似的场景，用这个就很合适。
Set:
public static void main(String[] args) {
// listNotSafe();
Set<String> set = new HashSet<>();
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();
}
}
因为HashSet和前面的ArrayList类似，也不是线程安全的，所以上面的会有ConcurrentModificationException;
问: HashSet是怎么实现的?
public HashSet() {
map = new HashMap<>();
}
诶？那一个KV对一个是就只是单个元素，怎么搞的？
找add:
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
PRESENT是个常量:
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
噢，原来value就是个new Object().
为什么value不是null? 因为既然set底层是map, 而map在remove(Object key``时返回value, 如果底层都是null`,不能区分是否是否remove成功
Map: 同:
Map<String, String> map = new HashMap<>();
for (int i = 0; i < 30; i++) {
new Thread(() -> {
map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 8));
System.out.println(map);
}, String.valueOf(i)).start();
}
报错: ConcurrentModificationException;
换map: ConcurrentHashMap:
碰到bug，四步走:
- 故障现象
- 导致原因
- 解决方案
- 优化建议
天下武功根本没有高低之分，只有习武之人有强弱之别
