Java学习笔记——集合III
线程安全的集合类
集合的线程安全问题
fast-fail 机制 —— 多个线程（通常情况下），在结构上对集合进行改变时。就有可能触发fast-fail机制，抛出java.util.ConcurrentModificationException异常
代码实例
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
list.add(i);
}
//多线程对list操作
//线程A对list进行遍历
new Thread(() ->{
for (Integer i : list) {
System.out.println(i); //Exception in thread "A" java.util.ConcurrentModificationException
}
} , "A").start();
//线程B对list进行添加操作
new Thread(() ->{
for (int i = 0; i < 10; i++) {
list.add(i);
}
},"B").start();
}
以ArrayList为例对集合进行遍历时，当调用内部迭代器的next方法时，会先调用checkForComodification方法
int expectedModCount = modCount; //开始遍历时，将modCount复制给expectedModCount
//而当调用add、remove等方法时 modCount会执行++ 操作
final void checkForComodification() {
if (modCount != expectedModCount) //当遍历时 ，如果其他线程对modCount进行了更改，则会使次条件为真
throw new ConcurrentModificationException();
}
常见的集合类，HashMap、LinkedList、ArrayList均为线程不安全的线程实现类
解决线程安全的三种方式
1）采用线程安全的集合类如Vector、HashTable等、此类集合中增删改查等方法均为同步方法
//Vector类中的get方法，使用synchronized同步
public synchronized E get(int index) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
但也因此，效率较低，现在较少采用
2）应用Collections.synchronizedList( List list ) / synchronizedMap(Map map) 方法
public E get(int index) {
synchronized (mutex) {return list.get(index);} //本质也是将集合中的方法进行同步
}
3）采用JUC包下提供的集合类CopyOnWriteArrayList 、 ConcurrentLinkedQueue、ConcurrentHashMap
CopyOnWriteArrayList
java.util.concurrent包下的线程安全的ArrayList
public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
// 底层依然是数组，只不过是volatile
private transient volatile Object[] array;
// 实例维护了一个可重入锁
final transient ReentrantLock lock = new ReentrantLock();
//获取size（）、get（）等方法并没有进行同步
public int size() {
return getArray().length;
}
}
add 、 remove等方法，进行了同步
add方法
//默认的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); //将新的数组重新赋值给array
return true;
} finally {
lock.unlock();
}
}
remove方法
public E remove(int index) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
E oldValue = get(elements, index);
int numMoved = len - index - 1;
if (numMoved == 0)
setArray(Arrays.copyOf(elements, len - 1));
else {
//新的数组长度为原数组长度减一
Object[] newElements = new Object[len - 1];
//将除欲删除元素之外的元素拷贝到新数组中
System.arraycopy(elements, 0, newElements, 0, index);
System.arraycopy(elements, index + 1, newElements, index,
numMoved);
//将新数组赋值给array
setArray(newElements);
}
return oldValue;
} finally {
lock.unlock();
}
}
set等方法类似
总结：
CopyOnWriteArrayList中，采用了读写分离的方式，对于读/获取长度等方法并未同步，而对于增删改等方法，采取了同步的方式，复制一份数组，对新的数组进行操作，操作完之后再将新的数组赋值给array，此过程中，并不影响其他线程的读操作。对于大多数场景下，此种方法即兼顾了效率，又解决了线程安全的问题。
ConcurrentHashMap
ConcurrentHashMap 同是juc包下的集合类，可以看作是线程安全的ConcurrentHashMap
该类在JDK1.7 与 JDK1.8 中的实现有所不同。
jdk1.7中的实现
jdk1.7中该类的实现原理就是将数据一段一段的存储，然后把每一段数据配一把锁。当以个线程占用锁访问其中一段数据的时候，其他段的数据也能被锁访问
初始化
1）初始化segment数组 长度通过ConcurrencyLevel得出（一定为2^n）
2）初始化segmentShift与segmentMask —— 用于定位segment
3）初始化每个segment —— HashEntry数组（默认大小为 容量 / segments的长度（取>= 其的2^n））
相关操作
get操作 —— 不加锁（变量定义为volatile） —— 直接读取
put操作 —— 对segment加锁（同样、扩容对segment扩容）
获取size —— 两次不加锁的获取size（）结果相同 ->返回 不同 所有segment加锁，再计算一次
jdk1.8中的实现
jdk1.8中ConcurrentHashMap的实现和之前有所不同，取消了Segment的概念，采用CAS与Synchronized的方式进行加锁，对集合的线程安全进行保障
一些重要的成员参数
简单列举部分ConcurrentHashMap中重要的变量
/*
sizeCtl：
0 未初始化，且数组的初始容量为16
正数 初始容量 / 扩容阈值 （容量 * 加载因子）
-1 正在进行初始化
其他负数 （-1 + n）正在扩容的线程个数 = n
*/
private transient volatile int sizeCtl;
// 静态内部类Node —— 替换HashEntry
static class Node<K,V> implements Map.Entry<K,V>
// table Node数组
transient volatile Node<K,V>[] table;
// 另一个Node数组 ， 仅在扩容的时候非空
private transient volatile Node<K,V>[] nextTable;
// BaseCount 用于统计Size
private transient volatile long baseCount;
// CounterCell 底层维护一个volatile的long值，用于统计Size
static final class CounterCell {
volatile long value;
CounterCell(long x) { value = x; }
}
// 内部类ForwardingNode 代表数组正在扩容
static final class ForwardingNode<K,V> extends Node<K,V>
初始化
该类的初始化数组长度，计算方法与之前版本以及HashMap的计算方法有所不同
相同的是ConcurrentHashMap也在第一次调用put方法之后，才对数组进行初始化
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
//tableSizeFor方法返回大于输入参数且最接近的2的整数次幂的数
//不同于HashMap，该类的容量为1.5倍参数 + 1的大于等于其的2的整数次幂
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
相关操作
put方法
public V put(K key, V value) {
return putVal(key, value, false);
}
putVal方法相对较为复杂，这里采用图示的方式对于其进行简单的解释
这里对addCount方法进行一个简单的解释
private final void addCount(long x, int check) {}
//首先会尝试对BaseCount进行修改
U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x))
//如果失败则尝试随机对于CounterCells 计数盒子中的数进行修改
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x)))
// 如若再失败，调用fullAddCount方法，循环修改CounterCells 知道成功位置
统计大小 size（）
public int size() {
long n = sumCount();
return ((n < 0L) ? 0 :
(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
(int)n);
}
// 将baseCount值与CounterCell的值相加返回，方法并非同步方法，相关变量为volatile变量
final long sumCount() {
CounterCell[] as = counterCells; CounterCell a;
long sum = baseCount;
if (as != null) {
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}
get方法与之前版本类似，并没有加锁
扩容
1.8中的扩容，仍然采用分治的方式，每个线程负责一部分（扩容线程最多为CPU核数），每个线程最少负责的桶数为16，以下，对于扩容具体的实现进行了简单的解释
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
//stride —— 每个线程需要负责的桶的个数
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // 最小值为16
if (nextTab == null) {...} // 如果nextTab为空，就先创建一个数组，长度为原数组的2倍（n << 1）
// ForwardingNode用于标识桶是否已被扩容
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// 具体扩容的过程，bound，i 用于标识索引与边界
for (int i = 0, bound = 0;;) {
while (advance) {} // 内部用于定位本轮需要处理的桶区间
}
if (i < 0 || i >= n || i + n >= nextn) {} //最后一个扩容线程的一些收尾工作
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd); // 桶位为空，直接方式forwardingNode
else if ((fh = f.hash) == MOVED)
advance = true; // 遇到fwd，同样跳过
else {
synchronized (f) {} //否则，对于头节点加锁，进行扩容（与HashMap类似两个链表loTail、hiTail，分别放置在对应的位置）
}
}
以上就是对于集合类的线程安全问题，以及相关解决方法的一些简单整理，欢迎大家批评指正。
540
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
