node结构
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 final int MOVED = -1; // hash for forwarding nodes forwardNode类型节点的hash
static final int TREEBIN = -2; // hash for roots of trees 树形节点hash
/**
* Table initialization and resizing control. When negative, the 负数时候是在初始化或者重建
* table is being initialized or resized: -1 for initialization,
* else -(1 + the number of active resizing threads). Otherwise,
* when table is null, holds the initial table size to use upon
* creation, or 0 for default. After initialization, holds the
* next element count value upon which to resize the table.
*/
private transient volatile int sizeCtl;
put以及transfer过程:
1、不允许Null的key或者value
2、一个死循环用来put,何时put成功何时跳出,第一次put初始化table
3、tabAt(tab, i = (n - 1) & hash)找到当前node应该在table位置处的node,若是为null,不加锁利用casTabAt()方法放进去,break
4、如果这个node不是null,而是forwardNode类型,说明这个节点以及被transfer了,这使用helpTransfer(tab, f);帮助transfer,得到新的table,进行下一次循环put
5、如果找到的node不是null,也不是forwardNode类型,即找到了链表或者tree的头结点,对这个头结点加锁
遍历链表或者tree,比较key和hash,找到则替换value,到尾节点则新加一个节点
6、transfer扩容方法,允许多个线程扩容,利用了private transient volatile Node<K,V>[] nextTable;以及forwardNode
一个线程扩容时候会把nextTable指向当前操作nextTab,另一个线程在put时候遇到forwardNode节点时候,使用helpTransfer,会先拿到nextTable,然后进入扩容方法,多个线程扩容操作的nextTable会是一个。
每次处理完table中i出节点,就会把这处的节点置为forwardNode节点类型
遍历到空节点,也置为forwardNode节点类型
如果遍历到forwardNode类型,则跳过不处理
拷贝节点以及list就跟hashmap类似,不过这个过程对头结点做了加锁
//原子操作
//可以理解为得到tab的i处节点
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);
}
//如果tab的i处节点为c,则更新为v
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);
}
//<span><span class="comment">设置节点位置的值</span><span> </span></span>
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}