写在前面的话
不应该在意起点,而要看向将要去到的地方。
继承关系
具体解释可看之前的文章
底层结构
1.8的数据结构
摒弃了分段锁的概念,启用 node + CAS + Synchronized 代替Segment
去掉了HashEntry结构
当前的 table【(n - 1) & hash】 == null 时,采用CAS操作
当产生hash冲突时,采用synchronized关键字
内部结构和HashMap相同,仍然使用: 数组 + 链表 + 红黑树
默认sizeCtl = 16,初始化时可以进行设置
基本属性
/**
* 最大的可能的表容量。该值必须为正好1<<30保持在Java数组分配和索引
* 两个表大小的权限,进一步需要因为32位哈希字段的前两位用于控制目的。
*/
//最大的容量
private static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认初始容量
*/
private static final int DEFAULT_CAPACITY = 16;
/**
*/
//最大数组大小
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 默认的并发度
*/
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/**
* 负载因子大小
*/
private static final float LOAD_FACTOR = 0.75f;
/**
* 对象使用树而不是列表时的bin计数阈值本。当向a添加一个元素时,箱子被转换为树至少有这么多节点的bin。这个值必须更大
* 大于2,且应至少为8,以符合假设删除关于转换回普通箱子的树收缩。
*/
//树化的临界值
static final int TREEIFY_THRESHOLD = 8;
/**
*/
//解除树化的值
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 容器可能被treeified的最小表容量。(否则,如果容器中有太多节点,将调整表的大小。)
* 需要避免的值至少为4 * TREEIFY_THRESHOLD调整大小和treeification阈值之间的冲突。
*/
//树化的最小容器数量
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 每个传送步骤的最小还原次数。范围是细分以允许多个大小调整线程。
* 这个值作为一个下界,以避免遇到大小调整器过度的内存争用。值应该是至少DEFAULT_CAPACITY。
*/
private static final int MIN_TRANSFER_STRIDE = 16;
/**
* 用于生成戳记的位数,单位为sizeCtl。对于32位数组必须至少为6。
*/
private static int RESIZE_STAMP_BITS = 16;
/**
* 可以帮助调整大小的最大线程数。必须适合32 - RESIZE_STAMP_BITS位。
*/
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
/**
* 记录尺寸戳记的位位移,单位为sizeCtl。
*/
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
可以看出相比1.7,增加了树化的相关临界属性,去除了Segment的相关属性
构造方法
无参构造方法
源码
public ConcurrentHashMap() {
}
默认大小为16
传入初始化大小的构造方法
为负数是抛出异常
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
动态调整sizeCtl
调用tableSizeFor方法
保证sizeCtl必须是2的n次方
传入一个map的构造方法
sizeCtl初始化也是16,然后将map中的元素全部put进ConcurrentHashMap
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
this.sizeCtl = DEFAULT_CAPACITY;
putAll(m);
}
传入初始化容量和加载因子
默认并发度为1
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, 1);
}
传入初始容量,负载因子和并发度
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;
}
输入的initialCapacity的大小来确定一个最小的且大于等于initialCapacity大小的2的n次幂,
如initialCapacity为15,则sizeCtl为16,若initialCapacity为16,则sizeCtl为16。
若initialCapacity大小超过了允许的最大值,则sizeCtl为最大值。
值得注意的是,构造函数中的concurrencyLevel参数已经在JDK1.8中的意义发生了很大的变化,其并不代表所允许的并发数,
其只是用来确定sizeCtl大小,在JDK1.8中的并发控制都是针对具体的桶而言,即有多少个桶就可以允许多少个并发数。
Node介绍
源码
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //key的hash值
final K key; //key
volatile V val; //value
volatile Node<K,V> next; //表示链表中的下一个节点
Node(int hash, K key, V val, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.val = val;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return val; }
public final int hashCode() { return key.hashCode() ^ val.hashCode(); }
}
这是1.8中构成每个元素的基本类
TreeNode
构造树的节点
static final class TreeNode<K,V> extends Node<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next,
TreeNode<K,V> parent) {
super(hash, key, val, next);
this.parent = parent;
}
}
TreeBin介绍
源码:
static final class TreeBin<K,V> extends Node<K,V> {
TreeNode<K,V> root;
volatile TreeNode<K,V> first;
volatile Thread waiter;
volatile int lockState;
// values for lockState
static final int WRITER = 1; // set while holding write lock //表示持有写锁
static final int WAITER = 2; // set when waiting for write lock //表示在等待写锁
static final int READER = 4; // increment value for setting read lock//表示正在设置读说
}
用作树的头结点,只存储root和first节点,不存储节点的key、value值。
ForwardingNode
在转移的时候放在头部的节点,是一个空节点
static final class ForwardingNode<K,V> extends Node<K,V> {
final Node<K,V>[] nextTable;
ForwardingNode(Node<K,V>[] tab) {
super(MOVED, null, null, null);
this.nextTable = tab;
}
}
常用方法
put
调用putVal方法,并且putVal的第三个参数设置为false
当设置为false的时候表示这个value一定会设置
true的时候,只有当这个key的value为空的时候才会设置
public V put(K key, V value) {
return putVal(key, value, false);
}
putVal方法
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException(); // 键或值为空,抛出异常
// 键的hash值经过计算获得hash值
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) { // 无限循环
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0) // 表为空或者表的长度为0
// 初始化表
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { // 表不为空并且表的长度大于0,并且该桶不为空
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null))) // 比较并且交换值,如tab的第i项为空则用新生成的node替换
break; // no lock when adding to empty bin
}
else if ((fh = f.hash) == MOVED) // 该结点的hash值为MOVED
// 进行结点的转移(在扩容的过程中)
tab = helpTransfer(tab, f);
else {
V oldVal = null;
synchronized (f) { // 加锁同步
if (tabAt(tab, i) == f) { // 找到table表下标为i的节点
if (fh >= 0) { // 该table表中该结点的hash值大于0
// binCount赋值为1
binCount = 1;
for (Node<K,V> e = f;; ++binCount) { // 无限循环
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) { // 结点的hash值相等并且key也相等
// 保存该结点的val值
oldVal = e.val;
if (!onlyIfAbsent) // 进行判断
// 将指定的value保存至结点,即进行了结点值的更新
e.val = value;
break;
}
// 保存当前结点
Node<K,V> pred = e;
if ((e = e.next) == null) { // 当前结点的下一个结点为空,即为最后一个结点
// 新生一个结点并且赋值给next域
pred.next = new Node<K,V>(hash, key,
value, null);
// 退出循环
break;
}
}
}
else if (f instanceof TreeBin) { // 结点为红黑树结点类型
Node<K,V> p;
// binCount赋值为2
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) { // 将hash、key、value放入红黑树
// 保存结点的val
oldVal = p.val;
if (!onlyIfAbsent) // 判断