//最大的容量
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) {