点击此处去Gitee上Clone源码下来在IDE上看效果更佳
/**
* 支持多个线程同时进行put，remove
* 迭代过程中，即使Map结构被修改，也不会抛出ConcurrentModificationException
* 除了数组+链表+红黑树，还增加了转移节点，保证了扩容时的线程安全，但是，迭代器一次只能由一个线程使用。
* 此类不允许将null用作键或值。
* put等修改方法只会锁单个槽点。
* 转移（扩容）时是一部分一部分地转移，当put等修改方法，遇到正在转移的槽点，会帮助转移。
*/
public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
implements ConcurrentMap<K, V>, Serializable {
private static final long serialVersionUID = 7249069246763182397L;
/* ---------------- Constants -------------- */
/**
* 可能的最大表容量
*/
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;
/**
* 转化为树的阈值
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 转化为链表的阈值
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 允许转化为树的最小数组容量
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 扩容过程中需要把旧数组上槽点转移到新槽点中，转移过程每条线程每次最少需要转移的最少槽点数
* 当一个线程来进行put等操作时，发现map正在扩容，就需要去帮助扩容
*/
private static final int MIN_TRANSFER_STRIDE = 16;
/**
* The number of bits used for generation stamp in sizeCtl.
* Must be at least 6 for 32bit arrays.
*/
private static int RESIZE_STAMP_BITS = 16;
/**
* 可以帮助扩容的最大线程数。必须为32-RESIZE_STAMP_BITS位。
*/
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
/**
* The bit shift for recording size stamp in sizeCtl.
*/
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
/*
* Encodings for Node hash fields. See above for explanation.
*/
static final int MOVED = -1; // 转移节点的hash
static final int TREEBIN = -2; // 树根的hash
static final int RESERVED = -3; // hash for transient reservations
static final int HASH_BITS = 0x7fffffff; // 用来算hash的
/**
* CPU线程数量，用于限制某些尺寸。
*/
static final int NCPU = Runtime.getRuntime().availableProcessors();
/**
* 用于序列化兼容性。
*/
private static final ObjectStreamField[] serialPersistentFields = {
new ObjectStreamField("segments", Segment[].class),
new ObjectStreamField("segmentMask", Integer.TYPE),
new ObjectStreamField("segmentShift", Integer.TYPE)
};
/* ---------------- Nodes -------------- */
/**
* 此类永远不会导出为用户可变的Map.Entry（即不支持setValue）
* 但可以用于遍历只读遍历。
*/
static class Node<K, V> implements Map.Entry<K, V> {
final int hash;
final K key;
volatile V val;
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();
}
public final String toString() {
return key + "=" + val;
}
public final V setValue(V value) {
throw new UnsupportedOperationException();
}
public final boolean equals(Object o) {
Object k, v, u;
Map.Entry<?, ?> e;
return ((o instanceof Map.Entry) &&
(k = (e = (Map.Entry<?, ?>) o).getKey()) != null &&
(v = e.getValue()) != null &&
(k == key || k.equals(key)) &&
(v == (u = val) || v.equals(u)));
}
/**
* Virtualized support for map.get(); overridden in subclasses.
*/
Node<K, V> find(int h, Object k) {
Node<K, V> e = this;
if (k != null) {
do {
K ek;
if (e.hash == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
} while ((e = e.next) != null);
}
return null;
}
}
/* ---------------- Static utilities -------------- */
/**
* 根据key的hash计算更奇妙的hash
*/
static final int spread(int h) {
return (h ^ (h >>> 16)) & HASH_BITS;
}
/**
* 对于给定的目标容量，返回两倍大小的幂。
* 比如输入17，返回32
* 输入40，返回64
*/
private static final int tableSizeFor(int c) {
int n = c - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
/**
* Returns x's Class if it is of the form "class C implements
* Comparable<C>", else null.
*/
static Class<?> comparableClassFor(Object x) {
if (x instanceof Comparable) {
Class<?> c;
Type[] ts, as;
Type t;
ParameterizedType p;
if ((c = x.getClass()) == String.class) // bypass checks
return c;
if ((ts = c.getGenericInterfaces()) != null) {
for (int i = 0; i < ts.length; ++i) {
if (((t = ts[i]) instanceof ParameterizedType) &&
((p = (ParameterizedType) t).getRawType() ==
Comparable.class) &&
(as = p.getActualTypeArguments()) != null &&
as.length == 1 && as[0] == c) // type arg is c
return c;
}
}
}
return null;
}
/**
* Returns k.compareTo(x) if x matches kc (k's screened comparable
* class), else 0.
*/
@SuppressWarnings({"rawtypes", "unchecked"}) // for cast to Comparable
static int compareComparables(Class<?> kc, Object k, Object x) {
return (x == null || x.getClass() != kc ? 0 :
((Comparable) k).compareTo(x));
}
/* ---------------- Table element access -------------- */
@SuppressWarnings("unchecked")
static final <K, V> Node<K, V> tabAt(Node<K, V>[] tab, int i) {
return (Node<K, V>) U.getObjectVolatile(tab, ((long) i << ASHIFT) + ABASE);
}
static final <K, V> boolean casTabAt(Node<K, V>[] tab, int i,
Node<K, V> c, Node<K, V> v) {
return U.compareAndSwapObject(tab, ((long) i << ASHIFT) + ABASE, c, v);
}
static final <K, V> void setTabAt(Node<K, V>[] tab, int i, Node<K, V> v) {
U.putObjectVolatile(tab, ((long) i << ASHIFT) + ABASE, v);
}
/* ---------------- Fields -------------- */
/**
* 底层数组，第一次插入才初始化。容量始值为2的幂
*/
transient volatile Node<K, V>[] table;
/**
* 下一张要用的表；仅在调整大小时不为null。
*/
private transient volatile Node<K, V>[] nextTable;
/**
* 基本计数器值，主要在没有竞争时使用，也用作表初始化期间竞争的后备。通过CAS更新。
*/
private transient volatile long baseCount;
/**
* 表初始化的和扩容控制
* <p>
* 如果为负值：
* -1表示正在初始化。
* 否则 -（1+正在进行扩容的线程数）
* <p>
* 当table为空时，保留创建底层数组时的长度，或者为0表示使用默认值
* table不为空时，表示下一次扩容的阈值
*/
private transient volatile int sizeCtl;
/**
* The next table index (plus one) to split while resizing.
*/
private transient volatile int transferIndex;
/**
* Spinlock (locked via CAS) used when resizing and/or creating CounterCells.
*/
private transient volatile int cellsBusy;
/**
* Table of counter cells. When non-null, size is a power of 2.
*/
private transient volatile CounterCell[] counterCells;
// views
private transient KeySetView<K, V> keySet;
private transient ValuesView<K, V> values;
private transient EntrySetView<K, V> entrySet;
/* ---------------- Public operations -------------- */
/**
* 使用默认大小实例化
*/
public ConcurrentHashMap() {
}
/**
* 使用传入大小实例化
*/
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
//如果initialCapacity大于等于MAXIMUM_CAPACITY除2
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;//记录数组初始化容量
}
/**
* 使用给定map实例化
*/
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
this.sizeCtl = DEFAULT_CAPACITY;//记录数组初始化容量
putAll(m);
}
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, 1);
}
/**
* @param concurrencyLevel 估计的并发更新线程数。该实现可以将该值用作调整提示。
*/
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel)
initialCapacity = concurrencyLevel; // 至少使用与估计线程数一样多的初始大小
long size = (long) (1.0 + (long) initialCapacity / loadFactor);
int cap = (size >= (long) MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int) size);
this.sizeCtl = cap;
}
// Original (since JDK1.2) Map methods
/**
* {@inheritDoc}
*/
public int size() {
long n = sumCount();
return ((n < 0L) ? 0 :
(n > (long) Integer.MAX_VALUE) ? Integer.MAX_VALUE :
(int) n);
}
/**
* {@inheritDoc}
*/
public boolean isEmpty() {
return sumCount() <= 0L; // ignore transient negative values
}
/**
* 寻找key对应的value
*/
public V get(Object key) {
Node<K, V>[] tab;
Node<K, V> e, p;
int n, eh;
K ek;
//计算hashcode
int h = spread(key.hashCode());
if ((tab = table) != null && (n = tab.length) > 0 &&//判断表是否初始化
(e = tabAt(tab, (n - 1) & h)) != null) {//寻找key的index
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
} else if (eh < 0)//如果不是链表，用对应的find方法
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;
}
/**
* 直接调get
*/
public boolean containsKey(Object key) {
return get(key) != null;
}
/**
* Returns {@code true} if this map maps one or more keys to the
* specified value. Note: This method may require a full traversal
* of the map, and is much slower than method {@code containsKey}.
*
* @param value value whose presence in this map is to be tested
* @return {@code true} if this map maps one or more keys to the
* specified value
* @throws NullPointerException if the specified value is null
*/
public boolean containsValue(Object value) {
if (value == null)
throw new NullPointerException();
Node<K, V>[] t;
if ((t = table) != null) {
Traverser<K, V> it = new Traverser<K, V>(t, t.length, 0, t.length);
for (Node<K, V> p; (p = it.advance()) != null; ) {
V v;
if ((v = p.val) == value || (v != null && value.equals(v)))
return true;
}
}
return false;
}
public V put(K key, V value) {
return putVal(key, value, false);
}
/**
* Implementation for put and putIfAbsent
*/
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
//计算hash
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K, V>[] tab = table; ; ) {
Node<K, V> f;
int n, i, fh;
//table为空则需要初始化
if (tab == null || (n = tab.length) == 0)
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//当前槽点为空，直接通过cas创建新节点，创建失败则重新循环
if (casTabAt(tab, i, null, new Node<K, V>(hash, key, value, null)))
break; // no lock when adding to empty bin
} else if ((fh = f.hash) == MOVED)//发现当前槽点是转移节点，既正在扩容中
tab = helpTransfer(tab, f);//帮助转移
else {
V oldVal = null;
synchronized (f) {//把槽点锁住
if (tabAt(tab, i) == f) {//检查槽点是否有变动
if (fh >= 0) {//负数表示有可能是TreeBin节点
binCount = 1;
for (Node<K, V> e = f; ; ++binCount) {
K ek;
if (e.hash == hash &&//判断hash值与key是否相同
((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) {//没有重复的key，则把新节点添加到尾部
pred.next = new Node<K, V>(hash, key,
value, null);
break;
}
}
} else if (f instanceof TreeBin) {
Node<K, V> p;
binCount = 2;
//按TreeBin的方式插入
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;
}
}
}
//增加计数，扩容检查等
addCount(1L, binCount);
return null;
}
/**
* 尝试调整表的大小以容纳给定数量的元素。
*/
public void putAll(Map<? extends K, ? extends V> m) {
tryPresize(m.size());
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
putVal(e.getKey(), e.getValue(), false);
}
/**
* 删除指定key的entry
*/
public V remove(Object key) {
return replaceNode(key, null, null);
}
/**
* 替换指定key的value，如果传入value为空，则删除
*/
final V replaceNode(Object key, V value, Object cv) {
int hash = spread(key.hashCode());//计算hash
for (Node<K, V>[] tab = table; ; ) {
Node<K, V> f;
int n, i, fh;
if (tab == null || (n = tab.length) == 0 ||
(f = tabAt(tab, i = (n - 1) & hash)) == null)//寻找不到指定key，结束
break;
else if ((fh = f.hash) == MOVED)//在转移中就去帮助转移
tab = helpTransfer(tab, f);
else {
V oldVal = null;
boolean validated = false;
synchronized (f) {
if (tabAt(tab, i) == f) {//判断槽点是否有变化
if (fh >= 0) {//为链表
validated = true;
for (Node<K, V> e = f, pred = null; ; ) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
V ev = e.val;
if (cv == null || cv == ev ||
(ev != null && cv.equals(ev))) {
oldVal = ev;
if (value != null)//value不等于空则替换值
e.val = value;
else if (pred != null)
//被删除节点在链表中
pred.next = e.next;
else
//要删除节点刚好在槽点上则把被删除节点的next移动到槽点处
setTabAt(tab, i, e.next);
}
break;
}
pred = e;
if ((e = e.next) == null)
break;
}
} else if (f instanceof TreeBin) {
validated = true;
TreeBin<K, V> t = (TreeBin<K, V>) f;
TreeNode<K, V> r, p;
if ((r = t.root) != null &&
//用树的方法寻找要替换的节点
(p = r.findTreeNode(hash, key, null)) != null) {
V pv = p.val;
if (cv == null || cv == pv ||
(pv != null && cv.equals(pv))) {
oldVal = pv;
if (value != null)
//替换值
p.val = value;
else if (t.removeTreeNode(p))//删除节点
setTabAt(tab, i, untreeify(t.first));
}
}
}
}
}
if (validated) {
if (oldVal != null) {
if (value == null)
//计数减1
addCount(-1L, -1);
return oldVal;
}
break;
}
}
}
return null;
}
//====以下就没有看了，战术撤退====//
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
