java concurrentmap原理_Java集合番外篇 -- ConcurrentHashMap底层实现和原理

最新推荐文章于 2023-03-21 22:26:35 发布

徐华伟

最新推荐文章于 2023-03-21 22:26:35 发布

阅读量150

点赞数

文章标签： java concurrentmap原理

本文链接：https://blog.csdn.net/weixin_42489714/article/details/114514056

版权

概述

距离上一次集合篇结束已经过了好久了，之前说要写一下番外，但是太忙了，总也找不出相对松散的时间，也有点静不下心来，最近花了点时间，于是便有了这篇博客。

在开始之前先介绍一个算法，这个算法和Concurrent的实现是分不开的。

CAS算法：

CAS是英文单词Compare And Swap的缩写，翻译过来就是比较并替换。

CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。

更新一个变量的时候，只有当变量的预期值A和内存地址V当中的实际值相同时，才会将内存地址V对应的值修改为B

从思想上来说，Synchronized属于悲观锁，悲观地认为程序中的并发情况严重，所以严防死守。CAS属于乐观锁，乐观地认为程序中的并发情况不那么严重，所以让线程不断去尝试更新。

ConcurrentHashMap是一个线程安全的Map集合，可以应对高并发的场景，保证线程安全。相比较HashTable，它的锁粒度更加的细化，因为HashTable的方法都是用Synchronized修饰的，效率灰常的底下。1.8之前ConcurrentHashMap使用锁分段技术，将数据分成一段段的存储，每一个数据段配置一把锁，相互之间不影响，而1.8之后摒弃了Segment(锁段)的概念，启用了全新的实现，也就是利用CAS+Synchronized来保证并发更新的安全，底层采用的依然是数组+链表+红黑树。本篇文章是基于JDK1.8 。

数据结构

继承关系

public class ConcurrentHashMap

extends AbstractMap

implements ConcurrentMap, Serializable

ConcurrentHashMap 继承了AbstractMap ,并且实现了ConcurrentMap接口。

与HashMap比对：

相同点：都集成了AbstractMap接口

不同点：HashMap实现了Map接口，ConcurrentHashMap实现了ConcurrentMap接口，而ConcurrentMap继承了Map接口，使用default关键字定义了一些方法。

从继承关系上看ConcurrentHashMap与HashMap并没有太大的区别。

基本属性

private static final int MAXIMUM_CAPACITY = 1 << 30; //最大容量2的30次方

private static final int DEFAULT_CAPACITY = 16; //默认容量 1<<4

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; //

private static final int MIN_TRANSFER_STRIDE = 16;

private static int RESIZE_STAMP_BITS = 16;

private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;

private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;

static final int MOVED = -1; // forwarding nodes 的hash值

static final int TREEBIN = -2; // roots of trees 的hash值

static final int RESERVED = -3; // transient reservations 的hash值

static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash

static final int NCPU = Runtime.getRuntime().availableProcessors(); //可用处理器数量

重点说一下 sizeCtrl属性：这个属性在ConcurrentHashMap中扮演者重要的角色。

//表初始化或者扩容的一个控制标识位

//负数代表正在进行初始化或者扩容的操作

// -1 代表初始化

// -N 代表有n-1个线程在进行扩容操作

//正数或者0表示没有进行初始化操作，这个数值表示初始化或者下一次要扩容的大小。

//transient 修饰的属性不会被序列化，volatile保证可见性

private transient volatile int sizeCtl;

构造方法

//无参构造方法，没有进行任何操作

public ConcurrentHashMap() {}

//指定初始化大小构造方法，判断参数的合法性，并创建了计算初始化的大小

public ConcurrentHashMap(int initialCapacity) {}

//将指定的集合转化为ConcurrentHashMap

public ConcurrentHashMap(Map extends K, ? extends V> m) {}

//指定初始化大小和负载因子的构造方法

public ConcurrentHashMap(int initialCapacity, float loadFactor) {

this(initialCapacity, loadFactor, 1);

}

//指定初始化大小，负载因子和concurrentLevel并发更新线程的数量，也可以理解为segment的个数

public ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel) {}

ConcurrentHashMap的构造方法并没做太多的工作，主要是进行了参数的合法性校验，和初始值大小的转换。这个方法 tableSizeFor()说明一下，主要的功能就是将指定的初始化参数转换为2的幂次方形式，如果初始化参数为9 ，转换后初始大小为16 。

内部数据结构

Node

首当其冲，因为它是ConcurrentHashMap的核心，它包装了key-value的键值对，所有插入的数据都包装在这里面，与HashMap很相似，但是有一些差别：

static class Node implements Map.Entry {

final int hash;

final K key;

volatile V val;

volatile Node next;

Node(int hash, K key, V val, Node next) {

this.hash = hash;

this.key = key;

this.val = val;

this.next = next;

}

value 和 next使用了volatile修饰，保证了线程之间的可见性。也不允许调用setValue()方法直接改变Node的值。并增加了find()方法辅助map.get()方法。

TreeNode

树节点类，另外一个核心的数据结构。当链表长度过长的时候，会转换为TreeNode。但是与HashMap不相同的是，它并不是直接转换为红黑树，而是把这些结点包装成TreeNode放在TreeBin对象中，由TreeBin完成对红黑树的包装。而且TreeNode在ConcurrentHashMap集成自Node类，而并非HashMap中的集成自LinkedHashMap.Entry类，也就是说TreeNode带有next指针，这样做的目的是方便基于TreeBin的访问。

TreeBin

这个类并不负责包装用户的key、value信息，而是包装的很多TreeNode节点。它代替了TreeNode的根节点，也就是说在实际的ConcurrentHashMap“数组”中，存放的是TreeBin对象，而不是TreeNode对象，这是与HashMap的区别。另外这个类还带有了读写锁。

ForwardingNode

一个用于连接两个table的节点类。它包含一个nextTable指针，用于指向下一张表。而且这个节点的key value next指针全部为null，它的hash值为-1. 这里面定义的find的方法是从nextTable里进行查询节点，而不是以自身为头节点进行查找

ConcurrentHashMap常用方法

initTable 初始化方法

初始化方法是很重要的一个方法，因为在ConcurrentHashMap的构造方法中只是简单的进行了一些参数校验和参数转换的操作。整个Map的初始化是在插入元素的时候触发的。这一点在下面的put方法中会进行说明。

//执行初始化操作，单线程操作

private final Node[] initTable() {

Node[] tab; int sc;

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

if ((sc = sizeCtl) < 0)

//sizeCtl < 0 表示有线程正在进行初始化操作，从运行状态变为就绪状态。

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

//设置SIZECTL的值为-1，阻塞其他线程的操作

//该方法有四个参数

//第一个参数：需要改变的对象

//第二个参数：偏移量

//第三个参数：期待的值

//第四个参数：更新后的值

else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {

try {

//再次检查是否有线程进行了初始化操作

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

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

@SuppressWarnings("unchecked")

//初始化Node对象数组

Node[] nt = (Node[])new Node,?>[n];

table = tab = nt;

//sc的值设置为n的0.75倍

sc = n - (n >>> 2); //相当于n*0.75

}

} finally {

sizeCtl = sc; //更改sizeCtl的值

}

break; //中断循坏返回

}

return tab; //返回初始化的值

}

扩容方法

当ConcurrentHashMap 容量不足的时候，需要对table进行扩容，这个方法是支持多个线程并发扩容的，我们所说的扩容，从本质上来说，无非是从一个数组到另外一个数组的拷贝。

扩容方法分为两个部分：

创建扩容后的新数组，容量变为原来的两倍，新数组的创建时单线程完成

将原来的数组元素复制到新的数组中，这个是多线程操作。

//帮助扩容

final Node[] helpTransfer(Node[] tab, Node f) {

Node[] nextTab; int sc;

if (tab != null && (f instanceof ForwardingNode) &&(nextTab = ((ForwardingNode)f).nextTable) != null) {

int rs = resizeStamp(tab.length);

while (nextTab == nextTable && table == tab &&(sc = sizeCtl) < 0) {

if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||

sc == rs + MAX_RESIZERS || transferIndex <= 0)

break;

if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {

transfer(tab, nextTab);

break;

}

return nextTab;

}

return table;

}

//tab = table ,nextTab 一个Node[]类型的变量

private final void transfer(Node[] tab, Node[] nextTab) {

//n 是tab的长度， stride 初始值为0

int n = tab.length, stride;

//判断cpu处理多线程的能力，如果小于16就直接赋值为16

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

stride = MIN_TRANSFER_STRIDE; // subdivide range

if (nextTab == null) { // initiating

try {

@SuppressWarnings("unchecked")

//构造一个容量是原来两倍的Node 类型数组

Node[] nt = (Node[])new Node,?>[n << 1];

nextTab = nt; //赋值

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

sizeCtl = Integer.MAX_VALUE;

return;

}

nextTable = nextTab; //赋值

transferIndex = n; //将数组长度赋值给transferIndex

}

int nextn = nextTab.length; //获取新数组的长度

ForwardingNode fwd = new ForwardingNode(nextTab); //创建fwd节点

boolean advance = true;

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

//使用for循环来处理每个槽位中的链表元素，CAS设置transferIndex属性值，并初始化i和bound值

// i 指当前的槽位序号，bound值需要处理的边界，先处理槽位为15的节点

for (int i = 0, bound = 0;;) {

//创建两个变量，一个为Node 类型，一个为int类型

Node f; int fh;

while (advance) {

int nextIndex, nextBound;

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

advance = false;

//将transferIndex的值赋值给 nextIndex ,并判断nextIndex的值是否小于等于0

else if ((nextIndex = transferIndex) <= 0) {

i = -1;

advance = false;

}

//更新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;

//如果table已经复制结束

if (finishing) {

nextTable = null; //清空nextTable

table = nextTab; //把nextTab 赋值给 table

sizeCtl = (n << 1) - (n >>> 1); //阈值设置为容量的1.5倍

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

}

//CAS算法获取某个数组节点，为空就设置为fwd

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

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

//如果某个节点的hash为-1，跳过

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

advance = true; // already processed

else {

//对头节点加锁，禁止其他线程进入

synchronized (f) {

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

//构造两个链表，将该节点的列表拆分为两个部分，一个是原链表的排列顺序，一个是反序

Node ln, hn;

if (fh >= 0) { // fh 当前节点的hash值若 >= 0

int runBit = fh & n;

Node lastRun = f; //将当前节点赋值给 lastRun 节点

for (Node 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 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(ph, pk, pv, ln);

else

hn = new Node(ph, pk, pv, hn);

}

//在nextTab 的i 位置上放置ln节点

setTabAt(nextTab, i, ln);

//在nextTab 的 i+n 位置上放置 hn节点

setTabAt(nextTab, i + n, hn);

//在tab节点i位置上插入插入forwardNode节点，表示该节点已经处理

setTabAt(tab, i, fwd);

advance = true;

}

//对TreeBin对象进行处理，过程与上面有些类似

//也把节点分类，分别插入到lo和hi为头节点的链表中

else if (f instanceof TreeBin) {

TreeBin t = (TreeBin)f;

TreeNode lo = null, loTail = null;

TreeNode hi = null, hiTail = null;

int lc = 0, hc = 0;

for (Node e = t.first; e != null; e = e.next) {

int h = e.hash;

TreeNode p = new TreeNode

(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;

}

//如果扩容后不在需要tree结构，反向转换成链表结构

ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :

(hc != 0) ? new TreeBin(lo) : t;

hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :

(lc != 0) ? new TreeBin(hi) : t;

setTabAt(nextTab, i, ln);

setTabAt(nextTab, i + n, hn);

setTabAt(tab, i, fwd);

advance = true;

}

put方法

put操作是最长用的方法，接下来看一下put()方法的具体实现：

put()要求键值都不能为空

需要经过两次散列，是数据均匀分散，减少碰撞的次数

判断tab是否进行了初始化，没有则调用initTable进行初始化操作(单线程)

数组i的位置没有元素存在，直接放入

如果i的位置在进行MOVE操作，也就是在进行扩容操作，则多线程帮助扩容

如果i的位置有元素存在，则在该节点加锁Synchronized，判断是链表还是红黑树，按照相应的插入规则插入

final V putVal(K key, V value, boolean onlyIfAbsent) {

//key|value == null 抛出异常

//ConcurrentHashMap不允许键或者值为null的这种情况发生

//这一点和HashMap有区别

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

//散列在散列，让数据均匀分布，减少碰撞次数

int hash = spread(key.hashCode()); -->static final int spread(int h) {return (h ^ (h >>> 16)) & HASH_BITS;}

int binCount = 0;

//死循环相当于while(true) ,将table赋值给 tab

for (Node[] tab = table;;) {

//创建一个Node类型的变量f , int 类型的变量 n i fh

Node f; int n, i, fh;

//判断tab是否为null ,是否进行了初始化操作，如果没有执行初始化，执行初始化操作

if (tab == null || (n = tab.length) == 0)

tab = initTable();

//tabAt 获取值

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

//添加到table中

if (casTabAt(tab, i, null,

new Node(hash, key, value, null)))

break; //退出循环 // no lock when adding to empty bin

}

//node的hash值为 -1

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

tab = helpTransfer(tab, f);

else {

V oldVal = null;

synchronized (f) {

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

if (fh >= 0) {

binCount = 1;

for (Node e = f;; ++binCount) {

K ek;

//key 相等，使用新值替换旧值

if (e.hash == hash &&((ek = e.key) == key ||(ek != null && key.equals(ek)))) {

oldVal = e.val;

if (!onlyIfAbsent)

e.val = value;

break;

}

Node pred = e;

//放在链表的尾部

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

pred.next = new Node(hash, key,value, null);

break;

}

//红黑树替换

else if (f instanceof TreeBin) {

Node p;

binCount = 2;

if ((p = ((TreeBin)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;

}

addCount(1L, binCount);

return null;

}

Get方法

Get方法也是最长用的方法，元素放入了，总要取出来

根据传入的key,获取相应的hash值

然后判断当前的table数组是否为空

计算指定的key在table中存储的位置

链表或者红黑树转换相依的方法处理

不存在则返回null

public V get(Object key) {

Node[] tab; Node e, p; int n, eh; K ek;

int h = spread(key.hashCode());

if ((tab = table) != null && (n = tab.length) > 0 &&

(e = tabAt(tab, (n - 1) & h)) != null) {

if ((eh = e.hash) == h) {

if ((ek = e.key) == key || (ek != null && key.equals(ek)))

return e.val;

}

//eh< 0 表示红黑树节点

else if (eh < 0)

return (p = e.find(h, key)) != null ? p.val : null;

//链表遍历

while ((e = e.next) != null) {

if (e.hash == h &&

((ek = e.key) == key || (ek != null && key.equals(ek))))

return e.val;

}

return null;

}

徐华伟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫