关系类图
HashMap
JDK 1.7 HashMap
创建HashMap
static final int MAXIMUM_CAPACITY = 1 << 30;
// 无参构造方法
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
// 有参构造方法， 初始化容量 - 加载因子(默认0.75)
public HashMap(int initialCapacity, float loadFactor) {
// 验证初始容量是否小于0
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// 如果初始化容量大于2^30次方， 则赋值最大初始容量为2^30
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// 如果加载因子小于0 或者 加载因子不是数字抛异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
threshold = initialCapacity;
// 空的方法 留给子类去实现
init();
}
初始化流程图
put 方法
public V put(K key, V value) {
// 验证hash表是否还未初始化 即为空的table
if (table == EMPTY_TABLE) {
// 进行hash表的初始化
inflateTable(threshold);
}
// 如果key为null，将数据存的数组中第一个位置上即table[0]位置，key为null计算hashCode结果也为0
if (key == null)
return putForNullKey(value);
// 获取key的hash
int hash = hash(key);
// 获取hash在数组中的下标位置
int i = indexFor(hash, table.length);
// 获取指定下标位置的Entry，如果存在Entry则验证是否存在相同的value如果存在则直接覆盖原有的值，并返回老值
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
// 修改记录+1
modCount++;
// 说明当前value在hash中不存在，添加新的value
addEntry(hash, key, value, i);
return null;
}
// 初始化hash表
private void inflateTable(int toSize) {
// 获取初始化容量,如果大于等2^30 则返回2^30，
// 如果大于1 则返回 当前值小于等于参数的最大2的幂，如果小于等于1 则返回1
int capacity = roundUpToPowerOf2(toSize);
// 计算最小的扩容临界点（容量*加载因子 或 2^30+1(加1是为了防止扩容)）
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
/**
* 获取hash表容量
* 1.如果大于等2^30 则返回2^30
* 2.如果大于1 则返回 当前值小于等于参数的最大2的幂(Integer.highestOneBit)
* 3.如果小于等于1 则返回1
*/
private static int roundUpToPowerOf2(int number) {
// assert number >= 0 : "number must be non-negative";
return number >= MAXIMUM_CAPACITY
? MAXIMUM_CAPACITY
: (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}
// 放入为null的key
private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
// 如果不存在重复的则添加新的元素
addEntry(0, null, value, 0);
return null;
}
// 获取key的hash值
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
// 获取所在数组的下标
static int indexFor(int h, int length) {
return h & (length-1);
}
addEntry 添加新的元素
// 添加新的元素 key的哈希值，key值，value值，所在元素的下标
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
// 扩容
resize(2 * table.length);
// 扩容后重新获取hash和数组下标
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
// 添加新的节点
createEntry(hash, key, value, bucketIndex);
}
// 创建新的节点，并在链表头部插入数据
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
resize 扩容
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
// 如果已经达到最大的长度则临界值赋值为int最大值
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
// 创建新的数组
Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity));
// 赋值新的数组
table = newTable;
// 重新计算临界值
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
// 转移数组 是否重新整理（重新计算hash）
// 循环老的数组 重新赋值到新的素组里面
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
添加数据流程图
内部类 Entry 链表
static class Entry<K,V> implements Map.Entry<K,V> {
final K key; // 当前元素key值
V value; // 当前元素value值
Entry<K,V> next; // 指向下一个Entry
int hash; // 当前key的hash值
}
数据结构
扩展说明
- 为什么容量最大是1<<30
在java中int是32位的
1<<30 = 1073741824
1<<31 = -2147483648
1<<32 = 1
在二进制中，最高位代表符号位0为正，1为负，当左移31位则最高位刚好是1所以为负数；左移32位，此时32位中全部为0此时为1 - 初始化后数组的容量是2的幂次方，即使指定的是非2的幂次方也会通过计算获取大于当前值的最小2的幂次方
- 在新增数据的时候是在链表头部添加数据 (头插法)
JDK 1.8 HashMap
创建HashMap
默认值指定一个加载因子，初始化table是在第一次put数据的时候
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
Node 类
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; // key的hash值
final K key; // 对应的key值
V value; // 对应的value值
Node<K,V> next; // 下一个节点
}
TreeNode 类
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; //
TreeNode<K,V> left; //
TreeNode<K,V> right; //
TreeNode<K,V> prev; //
boolean red;
}
put方法
通过key计算hash，根据hash和数组长度计算hash所在数组的下标，如果数组没有初始化会优先调用扩容方法进行初始化，如果当前数组下标没有节点则直接创建新的节点并添加到当前下标中。如果已经存在节点数据优先比较第一个节点和当前添加的key是否相等，相等则直接替换新的value，如果不相等验收是否是红黑树，是红黑树在红黑树添加数据，不是红黑树树则遍历链表判断是否有相等的节点如果有则直接覆盖新的value,如果不相等在链表尾部添加数据。如果链表长度大于等于8并且数组长度大于等于64则将链表转换成红黑树，如果链表长度大于等于8并且数据长度小于64则进行扩容处理。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
// 获取key的hash hash与hash高位进行异或运算
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
// 填充数据
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i; // 定义变量
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length; // 还没初始化进行扩容处理
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null); // 指定下标的数组节点为null则创建新的节点并赋值
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p; // 第一个节点先进行比较 如果key相等表示是同一个 赋值e为当前第一个节点
else if (p instanceof TreeNode)
// 如果是红黑树 则往红黑树添加数据
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 循环链表如果有相同的key则直接复制p后续会替换新值，
// 如果下一个节点为null则创建新的节点并添加到链表的尾部,如果长度大于等于8会将链表转成红黑树
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash); // 转成红黑树，当链表长度大于8并且数组长度大于等于64的时候才会转红黑树
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value; // 新值替换旧值
afterNodeAccess(e);
return oldValue;
}
}
++modCount; // 记录修改次数
if (++size > threshold)
resize(); // 验证是否需要扩容
afterNodeInsertion(evict);
return null;
}
// 链表转红黑树 如果数组长度小于64是不会转成红黑树的，会进行一次扩容
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
resize 扩容方法
会验证是否有初始化Node数组 如果没有会初始化默认容量的数组，如果已经初始化了会扩容到原来的2倍容量
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; // 原有节点数组
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) { // 如果原有容量大于0
if (oldCap >= MAXIMUM_CAPACITY) { // 如果原有容量大于最大容量则不进行扩容处理
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 新的容量并成原容量的2倍，如果新的容量小于最大容量并且原容量大于等于默认容量16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // 扩容临界变成原来的2倍
}
else if (oldThr > 0) // 如果原阀值大于0则赋值新的容量=原阀值
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY; // 默认新容量为16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 默认阀值为 容量*加载因子
}
if (newThr == 0) {
// 重新计算新的容量阀值
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;// 赋值扩容阀值
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; // 创建新的node数组
table = newTab; // 赋值新的数组
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) { // 循环将老数组里面的数据赋值到新的数组里面
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
数据结构
扩展说明
- 当前链表长度大于等于8并且数组长度大于等于64才会转换成红黑树，如果链表长度大于8并且数组长度小于64则只会进行扩容
JDK1.7 和 JDK1.8区别
- 数据结构 1.7：数组+链表，1.8：数组+链表+红黑树。
- 链表插入类型：1.7：在链表头部插入数据，1.8：在链表尾部插入数据。
- 创建：1.7：直接指定默认容量和加载因子，1.8：创建只指定加载因子
ConcurrentHashMap
JDK 1.7 ConcurrentHashMap
创建ConcurrentHashMap
static final int DEFAULT_INITIAL_CAPACITY = 16; // 默认初始容量
static final float DEFAULT_LOAD_FACTOR = 0.75f; // 默认加载因子
static final int DEFAULT_CONCURRENCY_LEVEL = 16; // 默认并发个数 就是
/**
* The maximum number of segments to allow; used to bound
* constructor arguments. Must be power of two less than 1 << 24.
* 允许的最大segments 个数，必须是小于2^24的2的幂次方 默认是2^16
*/
static final int MAX_SEGMENTS = 1 << 16;
/**
* Mask value for indexing into segments. The upper bits of a
* key's hash code are used to choose the segment.
* segments 的掩码值 segmentMask = ssize - 1, ssize通过计算获取到的segments数组个数
* key 的散列码的高位用来选择具体的 segment
*/
final int segmentMask;
/**
* Shift value for indexing within segments.
* 偏移量 segmentShift = 32-sshift，sshift是循环几次后确定segments数组的个数
*/
final int segmentShift;
/**
* The segments, each of which is a specialized hash table.
* segments数组
*/
final Segment<K,V>[] segments;
public ConcurrentHashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
// 初始化容量大小 加载因子 并发个数(Segment个数 指定后不可修改)
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
// 参数验证
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
// 并发个数不能超过最大并发个数
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
// Find power-of-two sizes best matching arguments
int sshift = 0;
int ssize = 1;
while (ssize < concurrencyLevel) { // 保证Segment个数是2的幂次方
++sshift;
ssize <<= 1;
}
this.segmentShift = 32 - sshift;
this.segmentMask = ssize - 1;
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
int c = initialCapacity / ssize;
if (c * ssize < initialCapacity)
++c;
int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c)
cap <<= 1;
// create segments and segments[0]
Segment<K,V> s0 =
new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
// segment数组个数
this.segments = ss;
}
Segment 内部类
Segment 继承了ReentrantLock(共享锁)
static final class Segment<K,V> extends ReentrantLock implements Serializable {
static final int MAX_SCAN_RETRIES = Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
transient volatile HashEntry<K,V>[] table; // 链表数组 存具体的数据
transient int count; // Segment中元素的数量
transient int modCount; // 对table的大小造成影响的操作的数量（比如put或者remove操作）
transient int threshold; // 阈值，Segment里面元素的数量超过这个值依旧就会对Segment进行扩容
final float loadFactor; // 负载因子，用于确定threshold
// put数据
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
// 尝试获取锁，如果获取锁失败则通过一直while循环（64次）获取锁，如果还是获取不到则对当前的Segment加锁
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash; // 获取hash所在HashEntry数组中的下标
HashEntry<K,V> first = entryAt(tab, index); // 通过CAS获取指定下标的HashEntry
for (HashEntry<K,V> e = first;;) {
if (e != null) {
K k;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;// 替换原有的值
if (!onlyIfAbsent) {
e.value = value;
++modCount;
}
break;
}
e = e.next;
}
else { // 当前HashEntry数组中对应的下标数据为空
if (node != null)
node.setNext(first);
else
node = new HashEntry<K,V>(hash, key, value, first);
int c = count + 1;// 元素个数+1
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
rehash(node); // 扩容
else
setEntryAt(tab, index, node); // 通过CAS添加元素
++modCount;// 修改次数+1
count = c; // 记录元素个数
oldValue = null;
break;
}
}
} finally {
unlock(); // 执行完释放锁
}
return oldValue;
}
// 扩容
private void rehash(HashEntry<K,V> node) {
HashEntry<K,V>[] oldTable = table; // 当前集合
int oldCapacity = oldTable.length; // 当前集合长度
int newCapacity = oldCapacity << 1; // 新的集合长度 为原来的1倍
threshold = (int)(newCapacity * loadFactor); // 新集合的扩容临界点
HashEntry<K,V>[] newTable =
(HashEntry<K,V>[]) new HashEntry[newCapacity]; // 创建新的集合
int sizeMask = newCapacity - 1;
for (int i = 0; i < oldCapacity ; i++) {// 循环老的集合添叫到新的集合
HashEntry<K,V> e = oldTable[i];
if (e != null) {
HashEntry<K,V> next = e.next;
int idx = e.hash & sizeMask;
if (next == null) // Single node on list
newTable[idx] = e;
else { // Reuse consecutive sequence at same slot
HashEntry<K,V> lastRun = e;
int lastIdx = idx;
for (HashEntry<K,V> last = next;
last != null;
last = last.next) {
int k = last.hash & sizeMask;
if (k != lastIdx) {
lastIdx = k;
lastRun = last;
}
}
newTable[lastIdx] = lastRun;
// Clone remaining nodes
for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
V v = p.value;
int h = p.hash;
int k = h & sizeMask;
HashEntry<K,V> n = newTable[k];
newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
}
}
}
}
int nodeIndex = node.hash & sizeMask; // add the new node
node.setNext(newTable[nodeIndex]);
newTable[nodeIndex] = node;
table = newTable;
}
}
HashEntry 内部类
static final class HashEntry<K,V> {
final int hash; // key的hash值
final K key; // key的值
volatile V value; // value的值
volatile HashEntry<K,V> next; // 指向下一个HashEntry
}
put方法
如果value为null则直接抛异常，value不为空。计算key的hash，根据hash获取对应的Segment，然后调用Segment的put方法添加元素
public V put(K key, V value) {
Segment<K,V> s;
if (value == null) // 如果value为空则抛异常
throw new NullPointerException();
int hash = hash(key); // 计算key的hash
int j = (hash >>> segmentShift) & segmentMask;
// 获取Segment
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
s = ensureSegment(j);
return s.put(key, hash, value, false); // 调用Segment put数据
}
get数据
通过计算key的hash获取对应的Segment 数组的下标，通过CAS获取对应的Segment元素，然后获取Segment 中HashEntry数组对应的下标获取具体的HashEntry，然后循环链表比较key和hash是否相等，相等则直接返回value
public V get(Object key) {
Segment<K,V> s; // manually integrate access methods to reduce overhead
HashEntry<K,V>[] tab;
int h = hash(key); // 获取key的hash值
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE; // 获取Segment数组的下标
// 通过CAS获取指定下标的Segment 并下标对应的HashEntry数组不为空
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
// 获取指定数组下标的HashEntry 并获取链表中的entry 如果key相等并且hash相等则直接返回对应的value
for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
e != null; e = e.next) {
K k;
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}
size 获取长度
通过无限for循环获取， 比较上一次循环和当前循环获取到的总修改次数如果两次相等则说明没有线程修改数据可以返回了，如果不相等则继续进行for循环。这个循环是有次数限制的默认循环3次。如果三次还获取不到则对没一个Segments加锁然后在统计所有的Segments中的个数。获取完成如果对Segments加锁了则进行锁释放。
public int size() {
final Segment<K,V>[] segments = this.segments;
int size;
boolean overflow; // true if size overflows 32 bits
long sum; // 当前循中所有Segment总修改次数
long last = 0L; // 上一次循环中所有Segment总修改次数
int retries = -1; // 重试次数
try {
for (;;) { // 进行无限循环 直到获取到长度
if (retries++ == RETRIES_BEFORE_LOCK) { // 默认循环3次还获取不到总数量 则对每一个segments加锁
for (int j = 0; j < segments.length; ++j)
ensureSegment(j).lock(); // force creation
}
sum = 0L;
size = 0;
overflow = false;
for (int j = 0; j < segments.length; ++j) {
// 通过cas获取当前下标下的Segment
Segment<K,V> seg = segmentAt(segments, j);
if (seg != null) {
sum += seg.modCount;
int c = seg.count;
if (c < 0 || (size += c) < 0)
overflow = true;
}
}
if (sum == last) // 上一次修改次数和当前修改次数一样说明没有线程在修改了 可以直接返回了
break;
last = sum;
}
} finally {
if (retries > RETRIES_BEFORE_LOCK) { // 如果对segments加锁则释放锁
for (int j = 0; j < segments.length; ++j)
segmentAt(segments, j).unlock();
}
}
return overflow ? Integer.MAX_VALUE : size;
}
数据结构
JDK 1.8 ConcurrentHashMap
put 方法
假设table已经初始化完成，put操作采用 CAS + synchronized 实现并发插入或更新操作：
- 当前bucket为空时，使用CAS操作，将Node放入对应的bucket中。
- 出现hash冲突，则采用synchronized关键字。倘若当前hash对应的节点是链表的头节点，遍历链表，若找到对应的node节点，则修改node节点的val，否则在链表末尾添加node节点；倘若当前节点是红黑树的根节点，在树结构上遍历元素，更新或增加节点。
- 倘若当前map正在扩容f.hash == MOVED， 则跟其他线程一起进行扩容
public V put(K key, V value) {
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
// key或value为null 则抛出空指针异常
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode()); // 获取key的hash
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
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) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
if (e.hash == hash &&
((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) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
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); // 统计节点个数，检查是否需要resize
return null;
}
initTable 初始化table数组
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
// 如果没有初始化则进行初始化
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0) // 如果有其他线程在初始化当前需要让出一下cpu
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { // 如果当前线程可以初始化则赋值sizeCtl=-1
try {
// 在验证一次是否需要初始化
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n]; // 创建数组
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
size 方法
ConcurrentHashMap的元素个数等于baseCounter和数组里每个CounterCell的值之和，这样做的原因是，当多个线程同时执行CAS修改baseCount值，失败的线程会将值放到CounterCell中。所以统计元素个数时，要把baseCount和counterCells数组都考虑。
public int size() {
long n = sumCount();
return ((n < 0L) ? 0 :
(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
(int)n);
}
final long sumCount() {
CounterCell[] as = counterCells; CounterCell a;
long sum = baseCount;
if (as != null) {
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}
JDK1.7 和 JDK1.8区别
- JDK1.7 使用的是分段锁每个segment继承ReentrantLock，JDK1.8使用的是CAS + synchronized保证并发更新
- 数据结构：JDK1.7：数组+链表， JDK1.8：数组+链表+红黑树
- 键值对：JDK1.7：HashEntry， JDK1.8：Node
扫一扫
191
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
