眾所周知腹忽，ArrayList -> List -> Collection, ArrayList線程不安全财骨。同理思喊，Map, Set都是線程不安全言沐。ArrayList總結(jié)起來就是: 初始化size為10的Object類型的數(shù)組。多并發(fā)修改值時可能: ConcurrentModificationException.
出現(xiàn)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()調(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擴容中绎秒，new/old交替賦值元素用的方法是Arrays.copyOf:
elementData = Arrays.copyOf(elementData, newCapacity);
如何用線程安全的ArrayList?
Vector. 但是浦妄，不好??尼摹，因為這是JDK 1.0的, 加了synchronized并發(fā)性下降见芹。實際上ArrayList是JDK 1.2的(Doug Lea)，就是為了解決并發(fā)性能低才有的這個類.
怎么辦?
Collections是工具類：Collections.synchronizedList(new ArrayList<>()).可以點進去看源碼, 和ArrayList的add方法的區(qū)別就是, 方法前面有沒有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容器進行并發(fā)的讀，這個讀不需要加鎖，因為當前容器不會添加任何元素惕它。所以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是怎么實現(xiàn)的?
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`,不能區(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();
}
報錯: ConcurrentModificationException;
換map: ConcurrentHashMap:
碰到bug，四步走:
- 故障現(xiàn)象
- 導致原因
- 解決方案
- 優(yōu)化建議
天下武功根本沒有高低之分，只有習武之人有強弱之別
