1:几个重要的成员变量:

private static final int MAXIMUM_CAPACITY = 1 << 30; //map 容器的最大容量

private static final int DEFAULT_CAPACITY = 16; // map容器的默认大小

private static final float LOAD_FACTOR = 0.75f;  //加载因子

static final int TREEIFY_THRESHOLD = 8;  //由链表转为树状结构的链表长度

static final int UNTREEIFY_THRESHOLD = 6; //由树状结构转为链表

static final int MIN_TREEIFY_CAPACITY = 64; //数组长度最小为64才会转为红黑树

transient volatile Node<K,V>[] table;  //Node数组 用于存储元素

private transient volatile Node<K,V>[] nextTable; //当扩容的时候用于临时存储数组链表

private transient volatile long baseCount; //保存着哈希表所有节点的个数总和,相当于hash      Map  size

private transient volatile int sizeCtl;

下面对sizeCtl这个属性进行说明:

  • 0:默认值
  • -1:代表哈希表正在进行初始化
  • 大于0:相当于 HashMap 中的 threshold,表示阈值
  • 小于-1:代表有多个线程正在进行扩容

由这些成员变量可以看到内部的数据结构是基于 数组+单链表 的数据结构的,其中链表会转化为树状结构;

2:构造方法

// 初始化 sizeCtl 参数

public ConcurrentHashMap(int initialCapacity,

float loadFactor, int concurrencyLevel) {

if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)

throw new IllegalArgumentException();

if (initialCapacity < concurrencyLevel)   // Use at least as many bins

initialCapacity = concurrencyLevel;   // as estimated threads

long size = (long)(1.0 + (long)initialCapacity / loadFactor);  //

int cap = (size >= (long)MAXIMUM_CAPACITY) ?

MAXIMUM_CAPACITY : tableSizeFor((int)size);

this.sizeCtl = cap;

}

3:几个重要的方法介绍 put  get remove三个方法的介绍;

3.1:put 方法:

public V put(K key, V value) {  //key=name1   value=aa

return putVal(key, value, false);

}

接下来看看putVal这个方法的具体实现:分为4部分来解析:

第一部分:

final V putVal(K key, V value, boolean onlyIfAbsent) { //key=name1  value=aa onlyIfAbsent=false

if (key == null || value == null) throw new NullPointerException();

int hash = spread(key.hashCode());  //获取到key的hash值

int binCount = 0;  // 赋值 binCount=0

for (Node<K,V>[] tab = table;;) {  //进入循环方法体

Node<K,V> f; int n, i, fh;

if (tab == null || (n = tab.length) == 0)  //如果是添加第一个元素进入扩容方法

tab = initTable();

else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {

if (casTabAt(tab, i, null,

new Node<K,V>(hash, key, value, null)))

break;                   // no lock when adding to empty bin

}

//接下来看看扩容方法的实现:

private final Node<K,V>[] initTable() {

Node<K,V>[] tab; int sc;

while ((tab = table) == null || tab.length == 0) {

if ((sc = sizeCtl) < 0)  //当有其他线程在进行扩容 当前线程yield 放弃cpu使用

Thread.yield(); // lost initialization race; just spin

else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {//通过CAS将sc更新为 -1

try {

//这里假设是第一次put操作时进行扩容   sc=-1

if ((tab = table) == null || tab.length == 0) {

int n = (sc > 0) ? sc : DEFAULT_CAPACITY; //n=16

@SuppressWarnings("unchecked")

Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n]; //新建一个长度为16的Node数组

table = tab = nt;  // 将nt赋值给成员变量table

sc = n - (n >>> 2); // sc=12

}

} finally {

sizeCtl = sc;  // sizeCtl=-1  这里保证当其他线程进入initTable方法时线程会被 yield;

}

break;

}

}

return tab;

}

第二部分:

接下来看看put方法的第二部分操作:

else if ((fh = f.hash) == MOVED)  // MOVED=-1

tab = helpTransfer(tab, f);

简单说明下上面的方法:当 数组中的链表正在迁移中(如:扩容的情况下),则进入该方法;表明帮助迁移

第三部分:

这一部分虽然看起来代码量比较大,但是具体的操作和hashmap类似,主要的区别是

对这个链表进行加锁后处理,synchronized对象锁后进行相应的操作。tabAt保证获取到的对象是可见性的;其他的操作和hashmap中是一致的;就不做过多的说明了;

V oldVal = null;

synchronized (f) {

if (tabAt(tab, i) == f) {

if (fh >= 0) {

binCount = 1;

for (Node<K,V> e = f;; ++binCount) {

K ek;

if (e.hash == hash &&

((ek = e.key) == key ||

(ek != null && key.equals(ek)))) {

oldVal = e.val;

if (!onlyIfAbsent)

e.val = value;

break;

}

Node<K,V> pred = e;

if ((e = e.next) == null) {

pred.next = new Node<K,V>(hash, key,

value, null);

break;

}

}

}

else if (f instanceof TreeBin) {

Node<K,V> p;

binCount = 2;

if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,

value)) != null) {

oldVal = p.val;

if (!onlyIfAbsent)

p.val = value;

}

}

}

}

if (binCount != 0) {

if (binCount >= TREEIFY_THRESHOLD)

treeifyBin(tab, i);

if (oldVal != null)

return oldVal;

break;

}

}

接下来看看第四部分的代码:在put 方法中只有一句,如下所示:

addCount(1L, binCount); //这里的 binCount是指对操作那个Node链表的长度

每次添加Node元素到链表中binCount都会加1

接下来主要是分析addCount 里面的方法:1:更新baseCount  2:判断是否需要扩容

private final void addCount(long x, int check) {  //x=1   check=4

CounterCell[] as; long b, s;

if ((as = counterCells) != null ||

!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {//将baseCount 更新为b + x 即总量+1

CounterCell a; long v; int m;

boolean uncontended = true;

if (as == null || (m = as.length - 1) < 0 ||

(a = as[ThreadLocalRandom.getProbe() & m]) == null ||

!(uncontended =

U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {

fullAddCount(x, uncontended);

return;

}

if (check <= 1)

return;

s = sumCount();

}

if (check >= 0) {  // 链表长度大于0

Node<K,V>[] tab, nt; int n, sc;

// sizeCtl=-1  s=0  tab!=null  n为node[] 数组的长度

while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&

(n = tab.length) < MAXIMUM_CAPACITY) {

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;

if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))  //sc更新为1

transfer(tab, nt);

}

else if (U.compareAndSwapInt(this, SIZECTL, sc,

(rs << RESIZE_STAMP_SHIFT) + 2))

transfer(tab, null);  //进入扩容的方法

s = sumCount();

}

}

}

下面看看 transfer的方法进入扩容的操作:

这个方法比较复杂,分为3个部分进行分析:

//这里tab为16的Node数组  nextTab为 null

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {

int n = tab.length, stride;

//计算单个线程允许处理的最少table桶首节点个数,不能小于 16

if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)

stride = MIN_TRANSFER_STRIDE; // subdivide range

//刚开始扩容  初始化nextTab

if (nextTab == null) {            // initiating

try {

@SuppressWarnings("unchecked")

Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1]; //创建长度为32的Node数组

nextTab = nt;  // nextTab为32的空数组

} catch (Throwable ex) {      // try to cope with OOME

sizeCtl = Integer.MAX_VALUE;

return;

}

nextTable = nextTab;  // nextTable变量为长度32的数组

transferIndex = n;  // transferIndex=32  指向数组的最后一个桶

}

int nextn = nextTab.length;

//定义ForwardingNode用于标记已经迁移完的桶

ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);

接下来看看扩容的第二部分:

boolean advance = true;

boolean finishing = false; // to ensure sweep before committing nextTab

// bound 表示当前线程需要处理桶节点区间的下限

for (int i = 0, bound = 0;;) {  //进入for循环,这里没有结束条件

Node<K,V> f; int fh;

while (advance) {

int nextIndex, nextBound;

if (--i >= bound || finishing)

advance = false;

else if ((nextIndex = transferIndex) <= 0) { // 这里 nextIndex=32 如果nextIndex<=0 则说明没有需要迁移的桶

i = -1;

advance = false;

}

//更新transferIndex

//为当前线程分配任务,处理桶区间为(nextBound, nextIndex)

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; // recheck before commit

}

}

else if ((f = tabAt(tab, i)) == null)

advance = casTabAt(tab, i, null, fwd);

else if ((fh = f.hash) == MOVED)

advance = true; // already processed

ConcurrentHashMap 源码分析,基于JDK1.8的更多相关文章

  1. HashMap 源码分析 基于jdk1.8分析

    HashMap 源码分析  基于jdk1.8分析 1:数据结构: transient Node<K,V>[] table;  //这里维护了一个 Node的数组结构: 下面看看Node的数 ...

  2. CopyOnWriteArrayList 源码分析 基于jdk1.8

    CopyOnWriteArrayList  源码分析: 1:成员属性: final transient ReentrantLock lock = new ReentrantLock();  //内部是 ...

  3. HashMap源码分析-基于JDK1.8

    hashMap数据结构 类注释 HashMap的几个重要的字段 hash和tableSizeFor方法 HashMap的数据结构 由上图可知,HashMap的基本数据结构是数组和单向链表或红黑树. 以 ...

  4. 【Java并发集合】ConcurrentHashMap源码解析基于JDK1.8

    concurrentHashMap(基于jdk1.8) 类注释 所有的操作都是线程安全的,我们在使用时无需进行加锁. 多个线程同时进行put.remove等操作时并不会阻塞,可以同时进行,而HashT ...

  5. ArrayList 源码分析 基于jdk1.8:

    1:数据结构: transient Object[] elementData;  //说明内部维护的数据结构是一个Object[] 数组 成员属性: private static final int ...

  6. LinkedList的源码分析(基于jdk1.8)

    1.初始化 public LinkedList() { } 并未开辟任何类似于数组一样的存储空间,那么链表是如何存储元素的呢? 2.Node类型 存储到链表中的元素会被封装为一个Node类型的结点.并 ...

  7. ArrayList的源码分析(基于jdk1.8)

    1.初始化 transient Object[] elementData; //实际存储元素的数组 private static final Object[] DEFAULTCAPACITY_EMPT ...

  8. 并发-ConcurrentHashMap源码分析

    ConcurrentHashMap 参考: http://www.cnblogs.com/chengxiao/p/6842045.html https://my.oschina.net/hosee/b ...

  9. AtomicInteger源码分析——基于CAS的乐观锁实现

    AtomicInteger源码分析——基于CAS的乐观锁实现 1. 悲观锁与乐观锁 我们都知道,cpu是时分复用的,也就是把cpu的时间片,分配给不同的thread/process轮流执行,时间片与时 ...

  10. Hashtable、ConcurrentHashMap源码分析

    Hashtable.ConcurrentHashMap源码分析 为什么把这两个数据结构对比分析呢,相信大家都明白.首先二者都是线程安全的,但是二者保证线程安全的方式却是不同的.废话不多说了,从源码的角 ...

随机推荐

  1. SQL Server 跨服务器、跨版本使用复制 (2008、2012)

    在两台不同的服务器间实现SQL Server 的发布和订阅,需要一些设置. 测试环境:2008数据库.2012数据库,可实现跨版本发布订阅 本次测试是08的数据库做发布端 ,使用08数据及12数据库均 ...

  2. 第三方web ide开发环境下vuejs开发HMR环境搭建-码农这样开发是快乐的!

    vuejs是一个非常优秀的前端框架,利用该框架可以快速开发出任何web app,之所以vuejs开发非常高效快捷,其中最重要的一点就是利用webpakc提供的HMR(热模块替换)特性,可以边写vue组 ...

  3. nodejs-翻转算法

    nodejs-翻转算法 /** * Created by moon on 2019/12/14. */ //程序运行完成时一定要有输出语句,本工具才能正确展示运行结果. function abc() ...

  4. Appium基于PO模型的自动化测试(Python)

    基于python单元测试框架unittest完成appium自动化测试,生成基于html可视化测试报告 代码示例: #利用unittest并生成测试报告 class Appium_test(unitt ...

  5. JVM 学习总结

    目录 Java内存区域 运行时数据区 & Java 内存结构 & Java 内存区域 1. 程序计数器 2. Java 虚拟机栈 3. 本地方法栈 4. 堆 5. 方法区 6. 运行时 ...

  6. Python分页

    # -*-coding:utf-8-*- # Author:Ds from django.utils.safestring import mark_safe from django.http.requ ...

  7. B+树的算法(java实现)

    定义 一颗m阶B+树满足以下几个条件: 1.除根节点外的节点的关键字个数最大为m-1,最小为m/2 2.除叶节点外的每个节点的孩子节点的数目为该节点关键字个数加一,这些孩子节点的的关键字的范围与父节点 ...

  8. 华为手机 android8.0APP更新时出现安装包解析异常的提示及安装闪退(无反应)问题

    在做android app升级更新时遇到几个问题,我用的测试机是华为V10 系统为8.0 一.安装闪退(无反应) 解决办法: 只要在Mainfest.xml 中加入权限编码即可解决 <uses- ...

  9. 201871010135 张玉晶《面向对象程序设计(java)》第十四周学习总结

    项目 内容 这个作业属于哪个过程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/zyja/p/11963 ...

  10. Access-Control-Allow-Origin 响应一个携带身份信息(Credential)的HTTP请求时,必需指定具体的域,不能用通配符

    https://www.cnblogs.com/raind/p/10771778.html Access-Control-Allow-Origin.HTTP响应头,指定服务器端允许进行跨域资源访问的来 ...