眾所周知，ArrayList -> List -> Collection, ArrayList線程不安全。同理，Map, Set都是線程不安全。ArrayList總結(jié)起來就是: 初始化size為10的Object類型的數(shù)組。多并發(fā)修改值時(shí)可能: ConcurrentModificationException.
出現(xiàn)ConcurrentModificationException的ArrayList舉例：30個(gè)線程同時(shí)對list進(jìn)行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:
- 同時(shí)對list讀寫:
ConcurrentModificationException. 解決辦法:Vector,Collections.synchronizedList(new ArrayList<>()),CopyOnWriteArrayList -
IllegalMonitorStateException: 沒有加lock/synchronized: 多線程爭搶操作資源類 - java自帶的
類.getClass().getClassLoader().**getParent()**...:NullPointerException; -
thread.start()調(diào)用多次: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擴(kuò)容中，new/old交替賦值元素用的方法是Arrays.copyOf:
elementData = Arrays.copyOf(elementData, newCapacity);
如何用線程安全的ArrayList?
Vector. 但是，不好??，因?yàn)檫@是JDK 1.0的, 加了synchronized并發(fā)性下降。實(shí)際上ArrayList是JDK 1.2的(Doug Lea)，就是為了解決并發(fā)性能低才有的這個(gè)類.
怎么辦?
Collections是工具類：Collections.synchronizedList(new ArrayList<>()).可以點(diǎn)進(jìn)去看源碼, 和ArrayList的add方法的區(qū)別就是, 方法前面有沒有synchronized修飾.
還有更吊的: java.util.concurrent包中的類: CopyOnWriteArrayList, 寫時(shí)復(fù)制。也是線程安全的.
為什么? 點(diǎn)進(jìn)去:
public CopyOnWriteArrayList() {
setArray(new Object[0]);
}
點(diǎn)進(jìn)去:
final void setArray(Object[] a) {
array = a;
}
點(diǎn)進(jìn)去:
/** 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這種寫時(shí)復(fù)制的容器，不是直接往那個(gè)容器添加元素，而是將當(dāng)前的容器elements進(jìn)行copy得到一個(gè)新的容器newElements,然后往新的容器中寫。寫完之后，把指向原來容器的引用指向新的容器setArray(newElements), 這樣在寫的時(shí)候并不影響從之前的容器中讀, i.e. 可以對CopyOnWrite容器進(jìn)行并發(fā)的讀，這個(gè)讀不需要加鎖，因?yàn)楫?dāng)前容器不會添加任何元素。所以CopyOnWrite是一種讀寫分離的思想，讀寫分離的容器。
當(dāng)然，這種Arrays.copyOf過于頻繁也不好，這種就看場景，如果是讀多寫少的場景, e.g. 跟mysql那種類似的場景，用這個(gè)就很合適。
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();
}
}
因?yàn)镠ashSet和前面的ArrayList類似，也不是線程安全的，所以上面的會有ConcurrentModificationException;
問: HashSet是怎么實(shí)現(xiàn)的?
public HashSet() {
map = new HashMap<>();
}
誒？那一個(gè)KV對一個(gè)是就只是單個(gè)元素，怎么搞的？
找add:
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
PRESENT是個(gè)常量:
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
噢，原來value就是個(gè)new Object().
為什么value不是null? 因?yàn)榧热籹et底層是map, 而map在remove(Object key``時(shí)返回value, 如果底層都是null`,不能區(qū)分是否是否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();
}
報(bào)錯: ConcurrentModificationException;
換map: ConcurrentHashMap:
碰到bug，四步走:
- 故障現(xiàn)象
- 導(dǎo)致原因
- 解決方案
- 優(yōu)化建議
天下武功根本沒有高低之分，只有習(xí)武之人有強(qiáng)弱之別
