ConcurrentHashMap1-8源码解读及如何保证线程安全，面试总结

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