线程安全集合类概述
- 遗留的线程安全集合类：HashTable、Vector；内部的各个方法如get、put、size等都使用synchronized修饰，性能较低
- Collections装饰的线程安全集合：synchronizedCollection、synchronizedList、synchronizedMap等等；内部通过传入一个线程不安全的集合对象，然后在Collections的方法中以synchronized修饰一个mutex对象的形式调用集合对象的方法来保证线程安全
JUC线程安全集合
- Blocking：大部分实现基于锁，并提供用来阻塞的方法
- CopyOnWrite：这类容器修改的开销相对较大
- Concurrent：内部很多操作使用cas优化，一般可以提供较高吞吐量；遍历时弱一致性，当迭代器遍历时如果容器修改，迭代器仍然可以遍历旧数据、求大小弱一致性，size操作未必100%正确、读取弱一致性
ConcurrentHashMap
单词计数
- 从26个文件中读取字母，最后统计每个字母出现的个数
- 使用单线程读取26个文件效率较低，可以每个文件对应一个线程去读取，但是读取到的数据最后要汇总，汇总的集合就需要线程安全，可以用到ConcurrentHashMap
生成测试数据
@Slf4j
public final class Demo{
static final String ALPHA = "abcdefghijklmnopqrstuvwxyz";
public static void main(String[] args){
int length = ALPHA.length();
int count = 200;
// 每个字母添加200个
List<String> list = new ArrayList<>(length*count);
for(int i=0;i<length;i++){
char ch = ALPHA.charAt(i);
for (int j = 0; j < count; j++) {
list.add(String.valueOf(ch));
}
}
// 打乱
Collections.shuffle(list);
for (int i = 0; i < 26; i++) {
try(PrintWriter printWriter = new PrintWriter(
new OutputStreamWriter(
new FileOutputStream("d://tmp/"+(i+1)+".txt")))){
String collect = list.subList(i*count,(i+1)*count).stream().collect(Collectors.joining());
printWriter.print(collect);
}catch (FileNotFoundException e){
e.printStackTrace();
}
}
}
}
字母计数实现
@Slf4j
public final class Demo{
static final String ALPHA = "abcdefghijklmnopqrstuvwxyz";
public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
// 使用累加器作为值，方便统计时的累加操作
ConcurrentHashMap<Character, LongAdder> map = new ConcurrentHashMap<>(26);
// 创建一个核心线程数和最大线程数相等的线程池，阻塞队列为SynchronousQueue大小为0
ThreadPoolExecutor pool = new ThreadPoolExecutor(26,26,0,
TimeUnit.MILLISECONDS, new SynchronousQueue<>());
CyclicBarrier barrier = new CyclicBarrier(27);
// 提交26个读取任务
for (int i = 0; i < 26; i++) {
int t = i;
pool.submit(()->{
try(FileReader reader = new FileReader("d://tmp/"+(t+1)+".txt")){
int c = 0;
while((c=reader.read())!=-1){
// computeIfAbsent可以原子的判断键是否存在，如果不存在则创建；因为判断是否存在和创建是两步操作，所以需要使用该方法保证原子性
LongAdder adder = map.computeIfAbsent((char)c,key->new LongAdder());
// 得到创建好的累加器，进行累加，每一个提交到累加器上的操作是原子的
adder.increment();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
try {
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
});
}
// 等待所有线程执行结束
barrier.await();
printMap(map);
}
private static <K,V> void printMap(Map<K,V> map){
for(K key:map.keySet()){
System.out.println(key+":"+map.get(key));
}
}
}
注意
ConcurrentHashMap线程安全的含义是方法是原子性的，但是上述操作中如果使用Integer作为值，先获取Integer再累加，或是先判断Integer是否存在再创建这都是在方法层面以外的两个操作，虽然每个操作都具有原子性，但是放在一起不具有原子性了
HashMap线程不安全的原因
1. JDK1.7HashMap死链
由于JDK7中，链表使用的是头插法，在扩容时会导致原有的链表顺序被逆序；且JDK7中的扩容后的rehash操作是直接在原数组上进行的，当两个线程同时扩容时，假设链表：a-b-c-null，线程1在rehash时会将尾部结点插在头部，变为：c-a-b-null，假设本来此时线程2已经到了c，接下来到null就结束循环，但由于线程1的影响导致c.next变为a所以会继续循环，同理线程1也会收到线程2的影响进入死循环
2. JDK1.8解决死链问题
JDK1.8中增加元素改为了尾插法，不会改变顺序，而且扩容后会创建一个新的数组并且将原数组的数据通过rehash将低位的结点放在新数组的原位置，高位的结点往后移动原容量的距离，解决了死链问题
3. JDK1.8数据覆盖问题
假设当前HashMap中某个容器中没有元素，此时插入数据不会遇到哈希碰撞则会直接插入元素，假设线程1在经过哈希碰撞判断后时间片用尽被挂起，此时线程2也经过哈希碰撞的判断将数据插入了容器，这时线程1醒来后也会将数据直接插入而不是接在线程2插入的后面(此时已经存在了哈希碰撞但是线程1不察觉)，导致线程2的数据被覆盖
4. JDK1.8size不一致问题
因为size没有被volatile修饰，所以工作内存中size的变化是互相不可见的，假设线程1和线程2都读取到size为1，当线程1将size增加为2后线程2未知，也会将size增加为2这样size就丢失了1的大小
ConcurrentHashMap-jdk8
重要属性和内部类
// 当初始化或扩容完成后，为下一次扩容的阈值大小
// 默认为0，初始化时为-1；扩容时为-(1+扩容线程数)
private transient volatile int sizeCtl;
// 内部的结点类，整个ConcurrentHashMap就是一个Node[]
static class Node<K,V> implements Map.Entry<K,V>{}
// 哈希表容器数组
transient volatile Node<K,V>[] table;
// 扩容时的新数组
private transient volatile Node<K,V>[] nextTable;
// 在扩容时，会在原数组从后往前遍历，每遍历完一个容器就在容器中加上一个ForwardingNode表示该容器上的结点已经转移到新数组中，此时其他线程获取结点时就知道该去新数组中获取
static final class ForwardingNode<K,V> extends Node<K,V>{}
// 用在compute以及computeIfAbsent进行计算时，用来占位，计算完成后替换为普通的Node
static final class ReservationNode<K,V> extends Node<K,V>{}
// 在map从链表升级为红黑树时，原数组的头结点会用TreeBin代替
static final class TreeBin<K,V> extends Node<K,V>{}
// 在map从链表升级为红黑树时，结点将会转化成TreeNode
static final class TreeNode<K,V> extends Node<K,V>{}
重要方法
// 获取Node[]中第i个Node，即第i个容器的头结点
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab,int i)
// 通过cas修改Node[]中第i个Node的值，c为旧值，v为新值
static final <K,V> boolean casTabAt(Node<K,V>[] tab,int i,Node<K,C> c,Node<K,V> v)
//直接求改Node[]中第i个Node的值，v为新值
static final <K,V> void setTabAt(Node<K,V>[] tab,int i,Node<K,V> v)
构造器分析
实现了懒惰初始化，在构造器中仅仅计算了table的大小，并没有初始化table，在第一次使用的时候才会真正的创建
/**
* @param initialCapacity 初始容量
* @param loadFactor 装载因子
* @param concurrencyLevel 并发度
*/
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel){
// 参数校验，装载因子和初始容量不能小于0，并发度必须大于0
if(!(loadFactor> 0.0f)|| initialCapacity<0||concurrencyLevel<=0)
throw new IllegalArgumentException();
// 初始容量如果小于并发度，则直接改为并发度，减少竞争
if(initialCapacity < concurrencyLevel)
initialCapacity = concurrencyLevel;
// 通过装载因子计算大小
long size = (long)(1.0+(long)initialCapacity/loadFactor);
// tableSizeFor 是为了保证计算的大小是2^n，即16，32，64等等；所以ConcurrentHashMap的大小并不一定是创建时指定的大小
int cap = (size >= (long)MAXIMUM_CAPACITY)?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
// 将计算出来的大小赋值给sizeCtl，第一次使用时用这个值来初始化数组
this.sizeCtl = cap;
}
get流程
public V get(Object key) {
Node<K,V>[] tab;Node<K,V> e,p;int n,eh;K ek;
// spread方法能确保hashCode为正整数
int h = spread(key,hashCode());
// 这两步判断table是否非空且有数据，否则直接返回null
if((tab==table) != null && (n==tab.length) > 0 &&
// 在初始化已经保证了table长度为2^n，除数满足是2^n时，按位与可以代替取模，同时按位与效率更高
// 这一步是为了找到目标容器并判断，通过哈希计算(取模/按位与)找到对应的数组下标，如果该容器为空，也直接返回null
(e=tabAt(tab, (n-1)&h)) != null) {
// 先比较头结点的哈希码，如果头结点哈希码和目标结点的哈希码相同，再进一步判断结点的键是否相同（先比较哈希码——>再使用equals比较key），都相同表示头结点就是目标结点，直接返回值
if(eh = e.hash) == h) {
if((ek = e.key) == key || (ek!=null&&key.equals(ek)))
return e.val;
}else if(eh<0)
// 如果头结点的哈希码是负数，则表示该节点是ForwordingNode或者TreeBin，则需要通过find方法来获取
return (p=e.find(h,key)) !=null?p.val:null;
// 向下遍历结点，找到一个满足哈希码相同，key的equals为true的结点，返回
while((e = e.next)!=null){
if(e.hash == h &&
((ek = e.key) == key|| (ek !=null&&key.equals(ek))))
return e.val;
}
}
return null;
}
put流程
public V put(K key,V value){
return putVal(key,value,false);
}
// onlyIfAbsent如果为true则表示只有当前结点不存在时才会添加数据，如果已经存在则不会添加
final V putVal(K key,V value,boolean onlyIfAbsent){
// 键值不许为null，HashMap允许键值为null(Hashtable不允许键值为null)
if(key==null||value==null) throw new NullPointerException();
// 保证key的哈希码为正整数
int hash = spread(key.hashCode());
int binCount = 0;
// 进入死循环
for(Node<K,V>[] tab = table;;){
Node<K,V> f;int n,i,fh;
// 如果哈希表为空或者长度为0，则调用initTable通过cas的方式初始化哈希表
if(tab==null||(n=tab.length)==0)
tab = initTable();
// 通过哈希计算找到目标容器，如果目标容器头结点为null，则表示容器中还没有结点，则直接使用cas来修改目标容器的头结点，如果cas成功则表示插入成功，退出循环；如果此时有另一个线程提前初始化了头结点，则进入下一轮循环，重新插入
else if((f = tabAt(tab,i=(n-1)&hash)) == null){
if(casTabAt(tab,i,null,new Node<K,V>(hash,key,value,null)))
break;
}
// 如果哈希码为MOVED(-1)表示正在扩容，则会帮助扩容线程进行扩容
else if((fh = f.hash)==MOVED)
tab = helpTransfer(tab,f);
// 进入这个分支表示桶下标冲突了，此时需要使用到synchronized独占锁
else {
V oldVal = null;
// 锁住链表的头结点，即锁住当前容器
synchronized(f){
// 再次确认头结点没有被移动
if(tabAt(tab,i) == f){
// 头结点哈希码大于0，表示当前还是链表，而不是红黑树
if(fh >= 0){
binCount = 1;
// 开始遍历链表找到具有相同key的结点
for(Node<k,V> e = f;;++binCount){
K ek;
// 比较哈希码与equals，取出旧值
if(e.hash == hash &&((ek=e.key)==key||(ek!=null&&key.equals(ek)))){
oldVal = e.val;
// 如果传入的onlyIfAbsent为false，即结点不存在也会插入数据，则将结点的值改为新值
if(!onlyIfAbsent)
e.val = value;
break;
}
Node<K,V> pred = e;
// 如果已经遍历遍历到最后一个结点，则将新的结点添加到最后
if((e = e.next)==null){
pred.next = nwe Node<K,V>(hash,key,value,null);
break;
}
}
}
// 如果头结点的哈希码小于0，表示当前容器中已经升级为红黑树
else if(f instanceof TreeBin){
Node<K,V> p;
binCount = 2;
// putTreeVal方法，会看key是否已经在书中，如果在则返回对应的TreeNode
if((p=((TreeBin<K,V> f).putTreeVal(hash,key,value))!=null){
oldVal = p.val;
// 取得树中的结点后，将新制插入
if(!onlyIfAbsent)
p.val = value;
}
}
}
}
if(binCount !=0 ){
// binCount在遍历链表的时候，会统计链表长度，如果链表长度达到了树化阈值(8)，则调用treeifyBin，内部会先判断当哈希表长度达到64后，如果链表长度还是达到了这个阈值，则会将链表转换为红黑树
if(binCount >= TREEIFY_THREASHOLD)
treeifyBin(tab,i);
if(oldVal!=null)
return oldVal;
break;
}
}
}
// 增加size的计数
addCount(1L,binCount);
return null;
}
private final Node<K,V> initTable(){
Node<K,V>[] tab;int src;
// 如果哈希表为null或者长度为0，表示哈希表还没有创建，则会循环不断尝试创建
while((tab = table)==null || tab.length==0){
// 如果sizeCtl小于0，表示已经有线程在扩容了，则调用yield方法让出cpu资源
if((sc = sizeCtl) < 0)
Thread.yield();
// 尝试通过cas将sizeCtl设置为-1，这个sizeCtl充当了一个cas锁的标志，只有一个初始化线程能够修改成功
else if(U.compareAndSwapInt(this，SIZECTL,sc,-1)){
try{
// 再次判断哈希表是否被初始化过
if((tab=table)==null||tab.length==0){
// 如果sizeCtl中存储的构造时计算出的大小不大于0，则使用默认大小
int n = (sc>0)?sc:DEFAULT_CAPACITY;
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
// 再次计算sc，表示下次要扩容时的阈值
sc = n-(n>>>2);
}
}finally{
// 将计算出来的阈值赋值给sizeCtl
sizeCtl = sc;
}
break;
}
}
return tab;
}
/**
* addCount方法类似LongAddr的累加，会创建多个累加单元进行累加，最后汇总
*/
// check是之前binCount的个数
private final void addCount(long x,int check) {
CounterCell[] as;long b,s;
if(
// 如果已经有了counterCells则向cell累加
(as=counterCells)!=null||
// 如果还没有创建counterCells，向baseCount累加
!U.compareAndSwapLong(this,BASECOUNT,b=baseCount,s=b+x)
){
CounterCell a;long v;int m;
boolean uncontended = true;
if(
// 还没有counterCells
as == null || (m=as.length-1) < 0||
// 还没有cell
(a = as[ThreadLocalRandom.getProbe() % m]) == null ||
// 使用cas进行累加操作，如果失败了表示冲突，则创建新的累加单元
!(uncontended = U.compareAndSwapLong(a,CELLVALUE,v=a.value,v+x))
){
// 创建累加单元数组和cell，累加重试
fullAddCount(x,uncontended);
return;
}
if(check<=1)
return;
// 获取元素个数
s = sumCount();
}
if(check>=0){
Node<K,V>[] tab,nt;int n,sc;
// 如果元素个数大于阈值，且表不为空，且数组长度没有超过最大值，表示需要扩容
// 循环的扩容，如果一次扩容失败或者不能达到预期，则会再次扩容
while(s>=(long)(sc=sizeCtl)&&(tab=table)!=null &&
(n = tab.length)<MAXIMUM_CAPATICY){
int rs = resizeStamp(n);
if(sc<0){
if((sc>>>RESIZE_STAMP_SHIFT!=rs||sc==rs+1||
sc==rs+MAX_RESIZERS||(nt=nextTable)==null||
transferIndex<=0)
break;
// 如果newtable已经创建了，则帮忙扩容
if(U.compareAndSwapInt(this,SIZECTL,sc,sc+1))
transfer(tab,nt);
}
// newtable还没有创建
else if(U.compareAndSwapInt(this,SIZECEL,sc,(rs<<RESIZE_STAMP_SHIFT)+2))
transfer(tab,null);
s = sumCount();
}
}
}
size计算流程
size计算实际发生在put，remove改变集合元素的操作之中；size计算之后只能得到一个大概值，得不到一个精确值
- 没有竞争发生，向baseCount累加计数
- 有竞争发生，新建counterCells，向其中一个cell累加计数
public int size(){
long n = sumCount();
return ((n<0L)?0:
(n>(long)Integer.MAX_VALUE)?Integer.MAX_VALUE:
(int)n);
}
final long sumCount(){
CounterCell[] as = counterCells;CounterCell a;
// 将baseCount计数与所有cell计数累加
long sum = baseCount;
if(as!=null){
for(int i=0;i<as.length;++i){
if((a=as[i])!=null)
sum += a.value;
}
}
return sum;
}
transfer扩容流程
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE;
// 如果nextTab为null，则初始化nextTab
if (nextTab == null) {
try {
@SuppressWarnings("unchecked")
// 在原有的table基础上长度×2
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
nextTab = nt;
} catch (Throwable ex) {
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
transferIndex = n;
}
int nextn = nextTab.length;
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
boolean advance = true;
boolean finishing = false;
// 以链表为单位，旧数组往新数组的搬迁
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
while (advance) {
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) {
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
i = n;
}
}
// 如果链表头为null，将链表头替换成forwardingNode
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
// 如果链表头已经是forwardingNode，则进入下一轮循环处理下一个链表
else if ((fh = f.hash) == MOVED)
advance = true;
// 处理链表
else {
// 锁住链表头
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
// 头结点的哈希码>=0表示是普通的链表结点
if (fh >= 0) {
int runBit = fh & n;
Node<K,V> lastRun = f;
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
for (Node<K,V> p = f; p != lastRun; p = p.next) {
int ph = p.hash; K pk = p.key; V pv = p.val;
if ((ph & n) == 0)
ln = new Node<K,V>(ph, pk, pv, ln);
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
// 红黑树结点
else if (f instanceof TreeBin) {
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> lo = null, loTail = null;
TreeNode<K,V> hi = null, hiTail = null;
int lc = 0, hc = 0;
for (Node<K,V> e = t.first; e != null; e = e.next) {
int h = e.hash;
TreeNode<K,V> p = new TreeNode<K,V>
(h, e.key, e.val, null, null);
if ((h & n) == 0) {
if ((p.prev = loTail) == null)
lo = p;
else
loTail.next = p;
loTail = p;
++lc;
}
else {
if ((p.prev = hiTail) == null)
hi = p;
else
hiTail.next = p;
hiTail = p;
++hc;
}
}
ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
(hc != 0) ? new TreeBin<K,V>(lo) : t;
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
(lc != 0) ? new TreeBin<K,V>(hi) : t;
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
ConcurrenthashMap-jdk7
在jdk7中，维护了一个segment数组，每个segment对应一把锁，Segment继承自ReentrantLock
- 优点：如果多个线程访问不同的segment，实际是没有冲突的
- 缺点：Segments数组默认大小是16，这个容量初始化指定后旧不能改变了，并且不是懒惰初始化
构造器分析
public ConcurrentHashMap(int initialCapacity,float loadFactor,int concurrencyLevel) {
// 参数有效性分析
if(!(loadFactor>0) || initailCapacity < 0||concurrency <= 0)
throw new IllegalArgumentException();
int sshift = 0;
int ssize = 1;
// 保证ssize达到并发度并且为2^n
while(ssize<concurrencyLevel) {
++sshift;
ssize<<=1;
}
// segmentShift默认是32-4=28
this.segmentShift = 32-sshift;
// segmentMask默认是15，即0000 0000 0000 1111
this.segmentMask = ssize-1;
if(initialCapacity > MAXIMUM_CAPACITY)
initailCapacity = MAXIMUM_CAPACITY;
int c = initialCapacity / ssize;
if(c*ssize<initialCapacity)
++c;
int cap = MIN_SEGMENT_TABLE_CAPACITY;
while(cap<c)
cap<<=1;
// 创建segments and segments[0]
// 一个segment对应一个哈希表
Segment<K,V> s0 =
new Segment<K,V>(loadFactor,(int)(cap*loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
UNSAFE.putOrderedObject(ss,SBASE,s0);
this.segments = ss;
}
segment定位
- ConcurrentHashMap1.7使用分段所Segment来保护不同分段的数据，那么在插入和获取的时候需要先通过哈希算法来定位到目标Segment
- 如根据某一hash求segment位置，先将高位向低位移动segmentShift位；再与segmentMask做按位与运算，得到最终的segment
put流程
public V put(K key,V value) {
Segment<K,V> s;
if(value==null)
throw new NullPointerException();
int hash = hash(key);
// 计算segment的下标
int j = (hash>>>segmentShifft)&segmentMask;
// 获去segment对象，判断是否为null，是则创建该segment，只有segment数组和segments[0]不是懒惰初始化，其他segment还是懒惰初始化的
if((s=(Segment<K,V> UNSAFE.getObject
(segments,(j<<SSHIFT)+SBASE)) == NULL){
// 这时不能确定是否真的为null，因为可能其他线程在同时创建了segment数组
// 因此再ensureSegment，用cas方式保证segment的安全性
s = ensureSegment(j);
}
// 到这里已经得到了一个非空的segment对象
// 进入segment的put流程
return s.put(key,hash,value,false);
}
// 这是Segment类中的put方法
final V put(K key,int hash,V value,boolean onlyIfAbsent){
// 尝试加锁
HashEntry<K,V> node = tryLock()?null:
// 如果加锁不成功，进入scanAndLockforPut流程
// 如果时多核cpu对多tryLock64次，进入lock流程(一次加锁没有成功则阻塞)
// 再尝试期间，还可以顺便查看该结点在链表中有没有，如果没有则创建出来
scanAndLockForPut(key,hash,value);
// 到这一步segment已经加锁完成，可以安全执行
V oldValue;
try{
HashEntry<K,V>[] tab = table;
// 经过哈希计算，获取到哈希表中的下标
int index = (tab.length-1) & hash;
// 根据下标得到链表的头结点
HashEntry<K,V> first = entryAt(tab,index);
// 进入循环
for(HashEntry<K,V> e = first;;){
// 结点非空的情况，判断目标结点是否已存在
if(e != null){
K k;
// 头结点的key和目标key相同，更新头结点的值
if((k = e.key) == key||
(e.hash == hash && key.equqls(k))){
oldValue = e.value;
if(!onlyIfAbsent){
e.value = value;
++modCount;
}
break;
}
// 结点后裔
e = e.next;
}
// 目标结点不存在，新增结点
else {
// 如果等待锁的时候已经创建过node，将node的next指向链表头(头插法)
if(node != null)
node.setNext(first);
// 如果获取锁很顺利，没有创建node，则创建一个node，将next指向链表头
else
node = new HashEntry<K,V>(hash,key,value,first)；
int c = count + 1;
// 如果结点数量超过阈值，进行扩容
if (c > threashold && tab.length < MAXIMUM_CAPACITY)
rehash(node);
// 如果节点数量没有超过阈值，将新的node作为链表头
else
setEntryAt(tab,index,node);
++modCount;
count = c;
oldValue = null;
break;
}
}
}finally{
unlock();
}
return oldValue;
}
rehash流程(扩容)
private void rehash(HashEntry<K,V> node) {
HashEntry<K,V>[] oldTable = table;
// 新的容量为旧容量的两倍
int oldCapacity = oldTable.length;
int newCapacity = oldCapacity << 1;
// 阈值更新为新容量*装载因子
threshold = (int) (newCapacity * loadactor);
// 创建新的哈希表
HashEntry<K,V>[] newTable = (HashEntry<K,V>[]) new HashEntry[newCapacity];
int sizeMask = newCapacity - 1;
// 遍历旧哈希表的结点，搬迁到新的哈希表中
for (int i=0;i<oldCapacity;i++) {
HashEntry<K,V> e = oldTable[i];
if(e != null) {
HashEntry<K,V> next = e.next;
// 通过哈希算法获得结点在新链表中的位置
int idx = e.hash & sizeMask;
// next为空表示当前容器链表中只有一个结点，则将结点直接放入新链表中即可
if (next == null)
newTable[idx] = e;
else {
HashEntry<K,V> lastRun = e;
int lastIdx = idx;
// 过一遍链表，尽可能把rehash后idx不变的结点重用
for(HashEntry<K,V> last = next;
last != null;
last = last.next){
int k = last.hash & sizeMask;
// 如果新的idx和旧的idx不一致，记录新的结点的位置和结点
if(k != lastIdx) {
lastIdx = k;
lastRun = last;
}
}
// 将旧结点放在新的位置上
newTable[lastIdx] = lastRun;
// 剩余结点需要新建
for(HashEntry<K,V> p = e;p != lastRun;p = p.next){
V v = p.value;
int h = p.hash;
int k = h & sizeMask;
HashEntry<K,V> n = newTable[k];
newTable[k] = new HashEntry<K,V>(h,p.key,v,n);
}
}
}
}
// 扩容完成，加入新节点
int nodeIndex = node.hash & sizeMask;
node.setNext(newTable[nodeIndex]);
newTable[nodeIndex] = node;
// 将旧的哈希表替换为新的哈希表
table = newTable;
}
get流程
get操作并未加锁，用了UNSAFE方法保证了可见性，扩容过程中，get先发生就从旧表中获取内容，get后发生就从新表中获取内容
public V get(Object key) {
Setment<K,V> s;
HashEntry<K,V>[] tab;
int h = hash(key);
// u为segment对象在数组中的偏移量
long u = (((h >>> segmentShift) & segmentMask)<<SSHIFT)+BASE;
// s即定位到的segment
if(( s = (Segment<K,V> UNSAFE.getObjectVolatile(segments,u)) != null &&
(tab = s.table != null) {
// 定位到目标数组，并遍历，找到对应的键
for(HashEntry<K,V> e = (HashEntry<K,V> UNSAFE.getObjectVolatile
(tab,((long)(((tab.length-1)&h)) << TSHIFT)+TBASE));
e != null; e = e.next) {
K key;
if((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}
size流程
- 计算元素个数前，先不加锁计算两次，如果前后两次结果一样，认为个数正确返回
- 如果两个结果不一样，进行重试，重试次数超过3，将所有segment锁住，重新计算个数返回
public int size(){
final Segment<K,V>[] segments = this.segments;
int size;
// size是否溢出
boolean overflow;
// modCount的总和
long sum;
// 上一次的结果
long last = 0L;
// 重试的次数
int retries = -1;
try{
for(;;){
// 如果超过重试次数，需要创建所有的segment并加锁
if(retries++ == RETRIES_BEFORE_LOCK){
for(int j = 0;j <segments.length;++j)
ensureSegment(j).lock();
}
sum = 0L;
size = 0;
overflow = false;
for(int j=0;j<segments.length;++j){
Segment<K,V> seg = segmentAt(segments,j);
if(seg != null) {
// segment中修改的次数
sum += seg.modCount;
// segment中元素的个数
int c = seg.count;
// 小于0表示溢出了
if(c < 0 || (size += c) < 0)
overflow = true;
}
}
// 如果两次的结果一样，则退出循环
if(sum == last)
break;
last = sum;
}
}finally {
// 如果发现重试次数超过了加锁阈值，表示加过锁了，则对segment进行解锁
if(retries > RETRIES_BEFORE_LOCK){
for(int j=0;j<segments.length;++j)
segmentAt(segments,j).unlock();
}
}
return overflow?Integer.MAX_VALUE:size;
}
LinkedBlockingQueue
基本的入队出队
public class LinkedBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>,java.io.Serializable{
// 队列内部维护的结点
static class Node<E>{
E item;
/**
* 真正的后继节点
* 发生在出队时指向自己
* null，没有后继结点
* /
Node<E> next;
Node(E x) { item = x; }
}
}
初始化链表
last = head = new Node<E>(null)，使用一个Dummy结点来占位，item为null
入队
一个新结点入队，让last指向新节点last = last.next = node
出队
Node<E> h = head;
Node<E> first = h.next;
// 断开头结点，即Dummy结点
h.next = h;
// 新的头结点指向
head = first;
// 获得需要返回的结点的值
E x = first.item;
// 将新的头结点设置为dummy结点
first.item = null;
return x;
加锁分析
用了两把锁和Dummy结点：
- 用一把锁，同一时刻，最多只允许有一个线程（生产者或消费者二选一）执行
- 用两把锁，分别锁住头和尾，同一时刻，可以允许两个线程同时（一个生产者与一个消费者）执行
线程安全分析
- 当节点总数大于2时（包括dummy结点），putLock保证last结点的线程安全，takeLock保证的是head结点的线程安全。两把锁保证了入队和出队没有竞争
- 当结点总数等于2时（一个dummy，一个正常），仍然时两把锁锁住两个对象，没有竞争
- 当结点总数等于1时（一个dummy），take线程会被notEmpty条件阻塞
put操作
public void put(E e) throws InterruptedException {
if(e == null) throw new NullPointerException();
int c = -1;
Node<E> node = new Node<E>(e);
// put相关的锁
final ReentrantLock putLock = this.putLock;
// count用来维护元素计数
final AtomicInteger count = this.count;
putLock.lockInterruptibly();
try{
// 如果队列满了，则notFull条件进入等待
while(count.get()==capacity){
notFull.await();
}
// 被唤醒后，入队且计数加一
enqueue(node);
c = count.getAndIncrement();
// 如果还有空位，则唤醒其他线程
if(c+1<capacity)
notFull.signal();
}finally{
putLock.unlock();
}
// 如果队列中有元素，叫醒take线程
if(c == 0)
// 为了减少竞争，这里调用的是notEmpty.signal()而不是notEmpty.signallAll()
signalNotEmpty();
}
与ArrayBlokingQueue性能比较
- Linked支持有界，Array强制有界
- Linked底层是链表，Array底层是数组
- Linked是懒惰的，Array需要提前初始化Node数组
- Linked每次入队会生成新的Node，而Array的Node是提前创建好的
- Linked两把锁，Array一把锁
ConcurrentLinkedQueue
ConcurrentLinkedQueue的设计与LinkedBlokingQueue非常像，也是用两把锁来锁住头尾，但是锁用cas来实现
CopyOnWriteArrayList
底层采用写入时拷贝的思想，增删改操作会将底层数组拷贝一份，更改操作在新数组上执行，不yi