JDK 1.7之 ConcurrentHashMap 源码分析
转载请注明出处:http://blog.csdn.net/crazy1235/article/details/76795383
- Segment HashEntry
- 构造函数
- put
- hash
- ensureSegment
- Segmentput
- rehash
- get
- remove
- Segmentremove
- replace
- Segmentreplace
- contains
- clear
- Segmentclear
- size
- 参考
JDK 1.5 引入了 ConcurrentHashMap 。
ConcurrentHashMap是线程安全且高效的HashMap。
HashTable容器使用synchronized来保证线程安全,但是在线程竞争激烈的情况下,HashTable的效率非常低。
当一个线程访问 HashTable 的同步方法时,其他线程也无法访问其他的同步方法,这样效率就很低下。
ConcurrentHashMap它采锁分段技术 来保证高效的并发操作!
ConcurrentHashMap把容器分为多个 segment(片段) ,每个片段有一把锁,当多线程访问容器里不同数据段的数据时,线程间就不会存在竞争关系;一个线程占用锁访问一个segment的数据时,并不影响另外的线程访问其他segment中的数据。
–
从下面两张图就可以看出 ConcurrentHashMap 的内部结构!
(图片转自网络,侵删)
对比于JDK1.7中的HashMap的结构,ConcurrentHashMap将数组每个元素作为一个segment–片段。
Segment的结构与HashMap类似,每个片段对应一个table数组和链表结构!
一个Segment里面包含一个HashEntry数组,每个HashEntry是一个链表结构,当对HashEntry数组的数据进行修改时,必须首先获得与它对应的Segment锁!
Segment & HashEntry
/*** The segments, each of which is a specialized hash table.*/final Segment<K,V>[] segments;
// 集成 ReentrantLockstatic final class Segment<K,V> extends ReentrantLock implements Serializable {private static final long serialVersionUID = 2249069246763182397L;static final int MAX_SCAN_RETRIES =Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;// 每一个segment对应一个HashEntry数组transient volatile HashEntry<K,V>[] table;// 总的元素个数transient int count;// 修改次数transient int modCount;// 阈值transient int threshold;// 加载因子final float loadFactor;// 构造函数Segment(float lf, int threshold, HashEntry<K,V>[] tab) {this.loadFactor = lf;this.threshold = threshold;this.table = tab;}// 往segment添加一个元素final V put(K key, int hash, V value, boolean onlyIfAbsent) {// ...}// 扩容数组,变为之前的两倍,重新打包之前的数据,然后把新的节点添加进去@SuppressWarnings("unchecked")private void rehash(HashEntry<K,V> node) {// ...}// private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {// ...}// private void scanAndLock(Object key, int hash) {// ...}// 当value为空或者key,value值都匹配到了删除节点final V remove(Object key, int hash, Object value) {// ...}// 根据key替换节点的值final boolean replace(K key, int hash, V oldValue, V newValue) {// ...}// 根据key替换节点的值final V replace(K key, int hash, V value) {// ...}// 清空segment中的元素节点final void clear() {// ...}}
/*** ConcurrentHashMap list entry. Note that this is never exported* out as a user-visible Map.Entry.*/static final class HashEntry<K,V> {final int hash;final K key;volatile V value;volatile HashEntry<K,V> next;HashEntry(int hash, K key, V value, HashEntry<K,V> next) {this.hash = hash;this.key = key;this.value = value;this.next = next;}/*** Sets next field with volatile write semantics. (See above* about use of putOrderedObject.)*/final void setNext(HashEntry<K,V> n) {UNSAFE.putOrderedObject(this, nextOffset, n);}// Unsafe mechanicsstatic final sun.misc.Unsafe UNSAFE;static final long nextOffset;static {try {UNSAFE = sun.misc.Unsafe.getUnsafe();Class k = HashEntry.class;nextOffset = UNSAFE.objectFieldOffset(k.getDeclaredField("next"));} catch (Exception e) {throw new Error(e);}}}
构造函数
// 默认初始容量
static final int DEFAULT_INITIAL_CAPACITY = 16;
// 默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 默认segment层级
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// segment最小容量
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
// 一个segment最大容量
static final int MAX_SEGMENTS = 1 << 16;
// 锁之前重试次数
static final int RETRIES_BEFORE_LOCK = 2;
public ConcurrentHashMap() {this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);}
public ConcurrentHashMap(int initialCapacity) {this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);}
public ConcurrentHashMap(int initialCapacity, float loadFactor) {this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL);}
@SuppressWarnings("unchecked")public ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel) {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;// segment数组的长度是由concurrentLevel计算来的,segment数组的长度是2的N次方,// 默认concurrencyLevel = 16, 所以ssize在默认情况下也是16,此时 sshift = 4// sshift相当于ssize从1向左移的次数int ssize = 1;while (ssize < concurrencyLevel) {++sshift; ssize <<= 1;}// 段偏移量,默认值情况下此时segmentShift = 28this.segmentShift = 32 - sshift;// 散列算法的掩码,默认值情况下segmentMask = 15this.segmentMask = ssize - 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<K,V> s0 =new Segment<K,V>(loadFactor, (int)(cap * loadFactor),(HashEntry<K,V>[])new HashEntry[cap]);// 创建ssize长度的Segment数组Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]this.segments = ss;}
initialCapacity 表示创建ConcurrentHashMap的初始容量。默认值是16
loadFactor 表示加载因子。当 ConcurrentHashMap中元素个数 > 最大容量 * loadFactor 时就需要进行扩容。
concurrencyLevel 表示并发的级别,也可以理解为segment数组的长度。Segment数组的长度 大于等于concurrencyLevel的第一个2的n次方。
理想情况下,有concurrentLevel个线程同时访问不同的segment数据,这样这些线程之间互不干扰,达到了最高并发级别!
put
添加元素分为两步:
- 定位到segment
- 判断是否需要对segment中的HashEntry数组进行扩容,然后再在segment中进行插入操作
public void putAll(Map<? extends K, ? extends V> m) {for (Map.Entry<? extends K, ? extends V> e : m.entrySet())put(e.getKey(), e.getValue());}
@SuppressWarnings("unchecked")public V putIfAbsent(K key, V value) {Segment<K,V> s;if (value == null)throw new NullPointerException();int hash = hash(key);int j = (hash >>> segmentShift) & segmentMask;if ((s = (Segment<K,V>)UNSAFE.getObject(segments, (j << SSHIFT) + SBASE)) == null)s = ensureSegment(j);return s.put(key, hash, value, true);}
@SuppressWarnings("unchecked")public V put(K key, V value) {Segment<K,V> s;if (value == null) // 不允许value为空throw new NullPointerException();int hash = hash(key); // 计算hash值int j = (hash >>> segmentShift) & segmentMask; // 定位属于哪个segment中if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegments = ensureSegment(j);return s.put(key, hash, value, false); // 将键值对保存到对应的segment中}
ConcurrentHashMap使用分段锁的机制来保护不同Segment的数据,那么插入和获取元素的时候,就需要先定位到Segment。
hash
// ?private transient final int hashSeed = randomHashSeed(this);private static int randomHashSeed(ConcurrentHashMap instance) {if (sun.misc.VM.isBooted() && Holder.ALTERNATIVE_HASHING) {return sun.misc.Hashing.randomHashSeed(instance);}return 0;}
private int hash(Object k) {int h = hashSeed;if ((0 != h) && (k instanceof String)) {return sun.misc.Hashing.stringHash32((String) k);}h ^= k.hashCode();// 此处使用的是Wang/Jenkins hash的变种算法!h += (h << 15) ^ 0xffffcd7d;h ^= (h >>> 10);h += (h << 3);h ^= (h >>> 6);h += (h << 2) + (h << 14);return h ^ (h >>> 16);}
此散列算法目的就是减少冲突,使元素能够比较均匀的分散到各个Segment中,从而提高整个容器的效率。
计算得到散列的hash值之后,就定位Segment数组中的哪个片段了。、
(hash >>> segmentShift) & segmentMask
默认情况下,segmentShift = 28, segmentMask = 15。
首先hash右移28位,让高四位参与运算。然后在于segmentMask进行与操作。就得到了segment数组的下标。
举例:
hash(key)运算得到的值是一个32位的整数。
默认情况下,this.segmentShift = 32 - sshift = 32 - 4 = 28。
ensureSegment
这个函数的目的就是找到对应的segment。
@SuppressWarnings("unchecked")private Segment<K,V> ensureSegment(int k) {final Segment<K,V>[] ss = this.segments;long u = (k << SSHIFT) + SBASE; // raw offsetSegment<K,V> seg;if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {Segment<K,V> proto = ss[0]; // use segment 0 as prototypeint 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) { // recheckSegment<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;}
找到了对应的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(key, hash, value);V oldValue;try {// 每一个segment对应一个HashEntry数组HashEntry<K,V>[] tab = table;// 计算对应HashEntry数组的下标// 每个segment中数组的长度都是2的N次方,所以这里经过运算之后,取的是hash的低几位数据int index = (tab.length - 1) & hash;// 定位到HashEntry数组中的某个结点(对应链表的表头结点)HashEntry<K,V> first = entryAt(tab, index);// 遍历链表for (HashEntry<K,V> e = first;;) {if (e != null) { // 如果链表不为空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.setNext(first);else// 根据key value 创建结点并插入链表node = new HashEntry<K,V>(hash, key, value, first);int c = count + 1;// 判断元素个数是否超过了阈值或者segment中数组的长度超过了MAXIMUM_CAPACITY,如果满足条件则rehash扩容!if (c > threshold && tab.length < MAXIMUM_CAPACITY)rehash(node);else // 不需要扩容时,将node放到数组(HashEntry[])中对应的位置setEntryAt(tab, index, node);++modCount;count = c;oldValue = null;break;}}} finally {unlock(); // 解锁}return oldValue; // 返回旧value值}
rehash
下面来看当需要扩容的时候:
/*** 两倍于之前的容量*/@SuppressWarnings("unchecked")private void rehash(HashEntry<K,V> node) {HashEntry<K,V>[] oldTable = table;int oldCapacity = oldTable.length;// 扩大1倍(左移一位)int newCapacity = oldCapacity << 1;// 计算新的阈值threshold = (int)(newCapacity * loadFactor);// 创建新的数组HashEntry<K,V>[] newTable =(HashEntry<K,V>[]) new HashEntry[newCapacity];// maskint 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;// 计算e对应的这条链表在新数组中对应的下标int idx = e.hash & sizeMask; if (next == null) // 只有一个结点时直接放入(新的)数组中newTable[idx] = e;else { // 链表有多个结点时:HashEntry<K,V> lastRun = e; // 就链表的表头结点做为新链表的尾结点int lastIdx = idx;for (HashEntry<K,V> last = next;last != null;last = last.next) {// 旧数组中一个链表中的数据并不一定在新数组中属于同一个链表,所以这里需要每次都重新计算int k = last.hash & sizeMask;if (k != lastIdx) {lastIdx = k;lastRun = last;}}// lastRun(和之后的元素)插入数组中。newTable[lastIdx] = lastRun;// 从(旧链表)头结点向后遍历,遍历到最后一组不同于前面hash值的组头。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; // add the new nodenode.setNext(newTable[nodeIndex]);newTable[nodeIndex] = node;table = newTable;}
以一条旧链表数据为例:
细心的朋友可以发现,这里并不一定遍历所有的链表元素,因为当后面的节点进过运算在新数据中的hash一样的话,只需要把这一组的头结点插入,后面的节点就会被带入其中。
所以,下面的for循环操作的是链表中lastRun节点之前的节点
for (HashEntry<K,V> p = e; p != lastRun; p = p.next)
get
首先找到对应的segment
然后找到segment中对应HashEntry链表
遍历链表即可
public V get(Object key) {Segment<K,V> s; // manually integrate access methods to reduce overheadHashEntry<K,V>[] tab;int h = hash(key);// 首先计算出segment数组的下标 ((h >>> segmentShift) & segmentMask))long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&(tab = s.table) != null) { // 根据下标找到segment// 然后(tab.length - 1) & h) 得到对应HashEntry数组的下标// 遍历链表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;}
remove
public V remove(Object key) {// 计算hash值int hash = hash(key);// 根据hash值找到对应的segmentSegment<K,V> s = segmentForHash(hash);// 调用Segment.remove 函数return s == null ? null : s.remove(key, hash, null);}
public boolean remove(Object key, Object value) {int hash = hash(key);Segment<K,V> s;return value != null && (s = segmentForHash(hash)) != null &&s.remove(key, hash, value) != null;}
Segment#remove
/*** Remove; match on key only if value null, else match both.*/final V remove(Object key, int hash, Object value) {if (!tryLock())scanAndLock(key, hash);V oldValue = null;try {HashEntry<K,V>[] tab = table;// 计算HashEntry数组下标int index = (tab.length - 1) & hash;// 找到头结点HashEntry<K,V> e = entryAt(tab, 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)// 当pred为空时,表示要移除的是链表的表头节点,重新设置链表setEntryAt(tab, index, next);elsepred.setNext(next);++modCount;--count;// 记录旧value值oldValue = v;}break;}pred = e;e = next;}} finally {unlock();}return oldValue;}
replace
替换元素的值
public boolean replace(K key, V oldValue, V newValue) {int hash = hash(key);// oldValue或者newValue为空时,抛出空指针异常if (oldValue == null || newValue == null)throw new NullPointerException();// 找到segmentSegment<K,V> s = segmentForHash(hash);// 调用Segment.replacereturn s != null && s.replace(key, hash, oldValue, newValue);}
public V replace(K key, V value) {int hash = hash(key);if (value == null)throw new NullPointerException();Segment<K,V> s = segmentForHash(hash);// 调用Segment.replacereturn s == null ? null : s.replace(key, hash, value);}
Segment#replace
final boolean replace(K key, int hash, V oldValue, V newValue) {if (!tryLock())scanAndLock(key, hash);boolean replaced = false;try {HashEntry<K,V> e;// entryForHash 用来找到链表头,然后for循环遍历链表for (e = entryForHash(this, hash); e != null; e = e.next) {K k;if ((k = e.key) == key ||(e.hash == hash && key.equals(k))) {// 当oldValue对应上了数据时,才会用newValue替换,然后返回trueif (oldValue.equals(e.value)) {e.value = newValue;++modCount;replaced = true;}break;}}} finally {unlock();}return replaced;}
final V replace(K key, int hash, V value) {if (!tryLock())scanAndLock(key, hash);V oldValue = null;try {HashEntry<K,V> e;for (e = entryForHash(this, hash); e != null; e = e.next) {K k;if ((k = e.key) == key ||(e.hash == hash && key.equals(k))) {// 这里没有判断value值,直接替换为新value值,返回旧value值oldValue = e.value;e.value = value;++modCount;break;}}} finally {unlock();}return oldValue;}
contains
判断是否包含key值对应的数据(节点)
1- 找到segment
2- 找到HashEntry
3- 遍历链表
@SuppressWarnings("unchecked")public boolean containsKey(Object key) {Segment<K,V> s; // same as get() except no need for volatile value readHashEntry<K,V>[] tab;int h = hash(key);long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;// 找到对应的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 k;// 判断if ((k = e.key) == key || (e.hash == h && key.equals(k)))return true;}}return false;}
判断是否包含value值对应的数据(节点)
public boolean contains(Object value) {return containsValue(value);}
public boolean containsValue(Object value) {// Same idea as size()if (value == null)throw new NullPointerException();final Segment<K,V>[] segments = this.segments;boolean found = false;long last = 0;// 重试次数int retries = -1;try {outer: for (;;) { // 死循环// 当重试次数等于3次时,直接遍历每个segment并上锁。if (retries++ == RETRIES_BEFORE_LOCK) {for (int j = 0; j < segments.length; ++j)ensureSegment(j).lock(); // force creation}long hashSum = 0L;int sum = 0;// 遍历segment数组for (int j = 0; j < segments.length; ++j) {HashEntry<K,V>[] tab;Segment<K,V> seg = segmentAt(segments, j);if (seg != null && (tab = seg.table) != null) {// 遍历某个segment对应的HashEntry数组for (int i = 0 ; i < tab.length; i++) {HashEntry<K,V> e;// 遍历HshEntry对应的链表for (e = entryAt(tab, i); e != null; e = e.next) {V v = e.value;// 如果找到了跳出outer循环if (v != null && value.equals(v)) {found = true;break outer;}}}// 记录总的修改次数sum += seg.modCount;}}// 如果前后两次得到的修改次数一致,就表示查找过程中没有其他线程修改元素,这是跳出循环if (retries > 0 && sum == last)break;// last保存上一次加起来的总修改次数last = sum;}} finally {if (retries > RETRIES_BEFORE_LOCK) {for (int j = 0; j < segments.length; ++j)segmentAt(segments, j).unlock();}}return found;}
在判断是否存在包含某个value时,有可能会出现另外一个线程插入一个节点,后者修改了一个节点的value数据。
所以为了保证准确定,该函数允许有三次机会去不加锁遍历segment,如果前后两次遍历segment之后发现modeCound总数是一样的,则表示前后过程中没有数据被修改,则可以使用遍历过程中的结果返回。
如果三次遍历之后,发现前后modeCount数据不一致,则直接遍历所有的segment并加锁,然后进行判断
clear
public void clear() {final Segment<K,V>[] segments = this.segments;// 遍历所有的segment清空for (int j = 0; j < segments.length; ++j) {Segment<K,V> s = segmentAt(segments, j);if (s != null)s.clear();}}
Segment#clear
final void clear() {lock(); // 上锁try {HashEntry<K,V>[] tab = table;for (int i = 0; i < tab.length ; i++)setEntryAt(tab, i, null); // 置空++modCount;count = 0;} finally {unlock(); // 解锁}}
size
计算 size 的思想类似于 containValue
public int size() {// final Segment<K,V>[] segments = this.segments;int size;boolean overflow; // true if size overflows 32 bitslong sum; // sum of modCountslong last = 0L; // previous sumint retries = -1; // first iteration isn't retrytry {// 死循环for (;;) {// 当重试次数等于3次时,直接遍历每个segment并上锁。if (retries++ == RETRIES_BEFORE_LOCK) {for (int j = 0; j < segments.length; ++j)ensureSegment(j).lock(); // force creation}sum = 0L;size = 0;// 遍历segment数组for (int j = 0; j < segments.length; ++j) {Segment<K,V> seg = segmentAt(segments, j);if (seg != null) {sum += seg.modCount;// 判断是否数据溢出// 注意这里计算元素总个数 (size += c)if (c < 0 || (size += c) < 0)overflow = true;}}// 如果前后两次数据一致,则可以跳出循环if (sum == last)break;last = sum;}} finally {if (retries > RETRIES_BEFORE_LOCK) {for (int j = 0; j < segments.length; ++j)segmentAt(segments, j).unlock();}}// 返回总元素个数return overflow ? Integer.MAX_VALUE : size;}
参考
https://my.oschina.net/hosee/blog/639352
http://blog.csdn.net/javazejian/article/details/76167357
https://my.oschina.net/hosee/blog/607677
http://www.importnew.com/22007.html
http://blog.csdn.net/xuefeng0707/article/details/40834595
http://www.cnblogs.com/ITtangtang/p/3948786.html
http://www.importnew.com/21781.html
http://www.importnew.com/15845.html
JDK 1.7之 ConcurrentHashMap 源码分析相关推荐
- ConcurrentHashMap源码分析,轻取面试Offer(一)
ConcurrentHashMap 这里主要分析的 jdk1.8中的ConcurrentHashMap,他是java之父Doug Lea之作,很多优秀的开源框架如tomcat.spring.中都大量用 ...
- ConcurrentHashMap源码分析,轻取面试Offer(二)
上篇ConcurrentHashMap源码分析,轻取面试Offer(一)中降到了看源码的方法,下面接上篇继续分析源码 先来上篇注释过的代码段和遗留的问题. final V putVal(K key, ...
- 【阅读源码系列】ConcurrentHashMap源码分析(JDK1.7和1.8)
个人学习源码的思路: 使用ctrl+单机进入源码,并阅读源码的官方文档–>大致的了解一下此类的特点和功能 使用ALIT+7查看类中所有方法–>大致的看一下此类的属性和方法 找到重要方法并阅 ...
- ConcurrentHashMap源码分析(2)——JDK1.8的实现
ConcurrentHashMap源码分析(1)--JDK1.7的实现 前言 在JDK1.7版本上,ConcurrentHashMap还是通过分段锁来实现的,Segment的数量制约着并发量.在JDK ...
- ConcurrentHashMap源码分析(1)——JDK1.7的实现
ConcurrentHashMap源码分析 ConcurrentHashMap源码分析(2)--JDK1.8的实现 前言 ConcurrentHashMap是线程安全且高效的HashMap的实现,在并 ...
- [JUC-5]ConcurrentHashMap源码分析JDK8
在学习之前,最好先了解下如下知识: 1.ReentrantLock的实现和原理. 2.Synchronized的实现和原理. 3.硬件对并发支持的CAS操作及JVM中Unsafe对CAS的实现. 4. ...
- Java源码详解六:ConcurrentHashMap源码分析--openjdk java 11源码
文章目录 注释 类的继承与实现 数据的存储 构造函数 哈希 put get 扩容 本系列是Java详解,专栏地址:Java源码分析 ConcurrentHashMap 官方文档:ConcurrentH ...
- JDK1.8 中 ConcurrentHashMap源码分析(一)容器初始化
上一篇文章中说到如何使用IDEA搭建JDK1.8阅读学习环境,JDK1.8源码下载及获取.导入IDEA阅读.配置JDK源码.这篇文章将学习ConcurrentHashMap源码
- 多线程高并发编程(10) -- ConcurrentHashMap源码分析
一.背景 前文讲了HashMap的源码分析,从中可以看到下面的问题: HashMap的put/remove方法不是线程安全的,如果在多线程并发环境下,使用synchronized进行加锁,会导致效率低 ...
最新文章
- 错误: libstdc++.so.6: cannot open shared object file: No such file or directory
- 在Word中插入条形码又一法
- UI5 table display visible row count logic calculation calculate
- 阿里云轻应用服务器 宝塔面板 mongodb 配置外网连接 其一 基础配置
- linux spring mvc tomcat配置,Spring MVC配置详解
- Linux下Zend Framework的“Invalid Controller Specified”问题
- 上市公司与不上市公司的区别
- 计算机犯罪法律,计算机犯罪的构成要件
- zookeeper编程入门系列之zookeeper实现分布式进程监控和分布式共享锁(图文详解)...
- Create umbraco website-On the road of umbraco (1)
- atmega328p 设置熔丝位,atmega328p 刷机
- C++ Beep函数播放歌曲《千本樱》
- 小汪Hibernate 学习之一 Hibernate 小例子
- 从设计心理学理解交互设计的原则
- 无法使用计算机名访问共享,局域网内无法用计算机名访问共享的解决办法
- 计算机应用基础高一考试,计算机应用基础 2018 高一《计算机应用基础》教学方法初探...
- Criteria教程
- linux一分钟关机命令,Linux关机命令集合
- 从后台得到webshell
- Java 高级 面试题 及 参考答案