今天参与了一个java的招聘,本人自己的能力其实也一般,但是不巧的是,今天那位同学水平也非常一般,很多问题自己都没去研究过,在问过他平时遇到过什么问题时,这个问题其实很一般,很一般,稍微用点心的,其实都能记住自己遇到的一些麻烦事吧,挑几个来说下就行,或者自己私下准备几个自己能理解的问题,但是他直接回答没什么问题。。。。平时就是一些增删改查啊,没什么很难的问题,说到此,我大概明白了他的日常工作了,基于需求,在SSM框架内增删改查,简单来说,就是我之前看到过一篇文章里总结的SSM型程序员,这种程序员值8K。(这个观点不是我的,是那篇文章的)。
但是他开价竟然是12K,这就没法接受了,现在功能型程序员也能有这么多钱么?这里我指的是只追求于用框架进行增删改查的程序员,而不想去研究其理,虽然不是每个程序员都能做技术型项目,但是也需要去研究你当前框架啊,也需要去研究你所使用的语言啊,但是上面这位一点没有,问过几个简单的java知识,茫茫然知道些东西,但是并不知道原理,因此在回答时总是抓不着要害进行回答,其实很多问题,只要你抓住要害,回答出本质,一般就没什么为难的。
废话有点多,知识感慨一下,希望自己不要变成这个样子,做个有追求的人吧。
今天研究一下ConcurrentHashMap。
底层图如下,熟悉这些集合必须先熟悉它们的底层结构,在结构上再去结合代码分析,事半功倍。
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
//initialCapacity和concurrencyLevel默认都是16,我们都先以默认值分析,loadFactor加载因子 0.75f,这些值和hashmap差不多
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
// Find power-of-two sizes best matching arguments
int sshift = 0;
int ssize = 1;
while (ssize < concurrencyLevel) {
//sshift其实是2的指数,ssize是大小
//1.假设都是传入0.75f,16.那么ssize是2^4=16,sshift是4
//2.假设传入的是0.75f,7.那么ssize是2^3=8,sshift是3.ssize是不小于concurrencyLevel的最小2次方的数
++sshift;
ssize <<= 1; // a. 1 * 2^1 = 2 b. 2 * 2^1 = 4 c. 4 * 2^1 = 8
//ssize是最终segment的大小
}
this.segmentShift = 32 - sshift; //segmentShift 为 32-n对于这个为什么是32,暂时不清楚,或许是下面移位的要求
this.segmentMask = ssize - 1; //segmentMask put时做与运算,表明当前数据在哪个segment中.segmentMask 为 2^n-1
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
int c = initialCapacity / ssize;
if (c * ssize < initialCapacity)
++c;
int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c)
cap <<= 1;
// create segments and segments[0]
//注意这块,segment[0]是在初始化时就新建出来了
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); // ordered write of segments[0]
this.segments = ss;
}
public V put(K key, V value) {
Segment<K,V> s;
if (value == null)
//值不能为null
throw new NullPointerException();
int hash = hash(key); //这边key也不能为null,不然做hash值会有NPE问题,不同于hashMap,在key为null时会有一个putNull操作。
//这边segmentShift 为32-4=28,将hash后的值无符号右移28位
//0000 0000 0000 0000 0000 0000 0000 xxxx,也就是决定落在哪个segment中是由hash值的高4位决定的
//segmentMask 在这边为 2^4 - 1 = 15
int j = (hash >>> segmentShift) & segmentMask;
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
//如果hash值处是null的话,初始化一个Segment
s = ensureSegment(j);
return s.put(key, hash, value, false);
}
//ensureSegment没什么好说的,底部采用CAS在hash值出去初始化一个Segment,
//使用ss[0]处的作为模型创建出来
private Segment<K,V> ensureSegment(int k) {
final Segment<K,V>[] ss = this.segments;
long u = (k << SSHIFT) + SBASE; // raw offset
Segment<K,V> seg;
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
Segment<K,V> proto = ss[0]; // use segment 0 as prototype
int cap = proto.table.length;
float lf = proto.loadFactor;
int threshold = (int)(cap * lf);
HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
== null) { // recheck
Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
== null) {
if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
break;
}
}
}
return seg;
}
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
//tryLock使用的是ReentrantLock,获取成功返回true,那么node就是null,获取失败,进入scanAndLockForPut流程
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value); //node值要么是null,要么是新node
V oldValue;
try {
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash; //此处和hashmap一致,获取这个key的hash值在table中的位置
HashEntry<K,V> first = entryAt(tab, index); //获取table中index位置的第一个元素,这个地方和上面scanAndLockForPut里类似
for (HashEntry<K,V> e = first;;) {
if (e != null) {
//e不为null时,循环遍历比较,和hashmap类似,获取old值,用于返回
K k;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;
if (!onlyIfAbsent) {
e.value = value;
++modCount;
}
break;
}
e = e.next;
}
else {
if (node != null)
//node不为null,说明scanAndLockForPut中新建了node,原本此处是null值,所以新建出来一个node,将node的next赋值为first,也就是null
node.setNext(first);
else
//node为null,说明要么是获取锁成功直接进入的,那么也是设置next为first,要么就是scanAndLockForPut返回null,说明此处原本有值。
//那么原本有值为什么HashEntry<K,V> first = entryAt(tab, index);为什么first是null呢?也是由于多线程的关系,可以试想一下,不难
node = new HashEntry<K,V>(hash, key, value, first);
int c = count + 1;
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
//超过阈值,rehash,暂时不care
rehash(node);
else
setEntryAt(tab, index, node); //此处将此node置于index处的第一个位置上,(不确定???)
++modCount;
count = c;
oldValue = null; //此处就能证明原本的值其实为null.在这个else逻辑段内的返回值是null
break;
}
}
} finally {
unlock();
}
return oldValue;
}
//tryLock失败时进入,说明此时已有线程获取到Segment处的锁了。
//根据下面的分析,总的来说,这个方法就是在获取锁失败时来确保当前线程是否需要新增node
//注意到这个方法,只要hash处不是null,那么就返回的null,如果是null,那么返回的是新node
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
HashEntry<K,V> first = entryForHash(this, hash); //获取这个Segment中对应hash值处的第一个enrty
HashEntry<K,V> e = first;
HashEntry<K,V> node = null;
int retries = -1; // negative while locating node
while (!tryLock()) {
//循环尝试获取锁
HashEntry<K,V> f; // to recheck first below
if (retries < 0) {
//retries为-1,即首次尝试,如果hash值处的entery为null,则新建一个entry node
if (e == null) {
if (node == null) // speculatively create node
node = new HashEntry<K,V>(hash, key, value, null);
retries = 0;
}
//一直后移,key相等时,尝试次数为0,说明不需要新建node了
else if (key.equals(e.key))
retries = 0;
else
e = e.next;
}
else if (++retries > MAX_SCAN_RETRIES) {
//当大于最大次数时,锁住,跳出
lock();
break;
}
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
//确保之前读取的该位置的值没有改变。
//有两张情况.
// 1.线程1进入时 原本此处为null,因此该线程在上面新建过一个node,此处判断时,线程2又改变了此处的值
// 1.1假设线程1再次tryLock时,成功了,那么线程1直接返回了刚刚创建的node,下面肯定会进入修改的逻辑,没毛病.假设线程2修改为<key,2>,那么线程1修改的值为<key,1>.
// 1.2假设线程2再次tryLock时,还是失败,那么此时线程1进入的是key判断流程,发现key是相等的,也是没毛病,等待获取锁
// 2.线程1进入时,此处是有node的,这种情况读者自己分析吧,原理一样的
e = first = f; // re-traverse if entry changed
retries = -1;
}
}
return node;
}
public V get(Object key) {
Segment<K,V> s; // manually integrate access methods to reduce overhead
HashEntry<K,V>[] tab;
int h = hash(key);
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
//依然做了两次hash定位,找到该查找元素的位置,然后去做循环,返回值
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 k;
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}
public V remove(Object key) {
int hash = hash(key);
//先将key做一次hash,定位Segment
Segment<K,V> s = segmentForHash(hash);
//取出当前所在的Segment,可以看见,在ConcurrentMap中,读取时不需要加锁
return s == null ? null : s.remove(key, hash, null);
}
final V remove(Object key, int hash, Object value) { //注意这边value传入的是null
if (!tryLock()) //尝试获取锁,成功返回true,失败返回false
scanAndLock(key, hash); //获取锁失败之后进入scanandlock流程,这个流程其实就是在做扫描的工作,直至获取到锁,执行下面的逻辑
V oldValue = null;
try {
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash;
HashEntry<K,V> e = entryAt(tab, index); //取出table中的index处的第一个值
HashEntry<K,V> pred = null; //前驱节点
while (e != null) {
K k;
HashEntry<K,V> next = e.next;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) { //此处刚好第一个节点就是需要删除的
V v = e.value;
if (value == null || value == v || value.equals(v)) {
if (pred == null) //如果此时prev是null,说明没有后移过,再次保证首节点是需删除节点
setEntryAt(tab, index, next); //设置index处的值为next节点
else
pred.setNext(next); // pred不是null,说明此时e指向的next节点是需要删除的,直接将pred指向next,也就是e.next.next节点。注意此时e指向next
++modCount;
--count;
oldValue = v;
}
break;
}
pred = e; //当前节点不是需删除节点, prev指向当前
e = next; // 当前节点后移
}
} finally {
unlock();
}
return oldValue; //最终return旧值
}
//正如注释所说,类似上面的scan操作,但是简单许多
//首先我们发现这个方法并没有返回值,那这个方法的意义何在呢?
//我们可以看见tryLock那个方法
//假设外层的tryLock没有获取到锁,
//1.那么进入这个方法之后立马获取到了,那么此时这个锁仍然锁在了当前Segment上了
//2.进入方法后第一次没有获取到锁,那么之后不管执行1,2,3,4哪一个逻辑,最终这个锁仍然是加在当前Segment上。
//那么可以猜想这个方法其实是保证外层没有获取到锁的线程,在这个方法内不断轮询,但是仍保证锁是加在当前Segment上
private void scanAndLock(Object key, int hash) {
// similar to but simpler than scanAndLockForPut
HashEntry<K,V> first = entryForHash(this, hash); //获取table中hash值处的第一个entry。
HashEntry<K,V> e = first;
int retries = -1;
while (!tryLock()) { //这边依然是轮询
HashEntry<K,V> f;
if (retries < 0) {
if (e == null || key.equals(e.key))
retries = 0; //1
else
e = e.next; //2
}
else if (++retries > MAX_SCAN_RETRIES) {
lock(); //3
break;
}
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
e = first = f; //4
retries = -1;
}
}
}
基于上面分析,画个图吧,假设现在map中存储的数据如下:需要删除的数据为entry2.
第一次进入时e指向entry1,next指向entry2
第一次没有找到需要删除的entry2,进入第二次循环。
第二次找到了,因此将pred指向的entry1的next指向e.next。也就是entry3,对于concurrentHashMap的内部图删除分析不难。
那么,万一在读取时刚刚好删除了咋办呢?不要紧,可以去看看Segment和Entry内部变量的类型定义,都是volatile的,基于happen-before原则,读都是在写之后的,可以保证读取的都是最新的数据。