ConcurrentHashMap
2017-07-17 17:52
169 查看
ConcurrentHashMap继承了AbstractMap,实现了AbstractMap和Serializable接口。
ConcurrentHashMap是支持高并发的hashMap。
另外一个重要的存储结构是ForwardingNode,ForwardingNode继承Node,内部有一个final类型的数组,及节点信息,重写了find方法,方便在内部数组查找信息。
几个重要的值
下面根据常用的流程来梳理其内部结构。首先是最常用的put(K key, V value)方法。put方法会调用putVal(key, value, false)方法。
initTable()
helpTransfer
到这里,关于put的所有方法已经完成。
* get(Object key)*
ConcurrentHashMap是一个比较难的类,看过之后还是一知半解,还需要不断学习。
ConcurrentHashMap是支持高并发的hashMap。
//节点信息保存了对应的hash值、key、value,及下一节点信息,但是value和下一节点信息用volatile 修饰,保证可见性。 static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; volatile V val; //volatile修饰,保证可见性 volatile Node<K,V> next; //volatile修饰,保证可见性 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; } //不允许直接修改value值,但是增加了一个find帮助类。 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(); */ 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; } }
另外一个重要的存储结构是ForwardingNode,ForwardingNode继承Node,内部有一个final类型的数组,及节点信息,重写了find方法,方便在内部数组查找信息。
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; } Node<K,V> find(int h, Object k) { outer: for (Node<K,V>[] tab = nextTable;;) { Node<K,V> e; int n; if (k == null || tab == null || (n = tab.length) == 0 ||(e = tabAt(tab, (n - 1) & h)) == null) return null; for (;;) { int eh; K ek; if ((eh = e.hash) == h &&((ek = e.key) == k || (ek != null && k.equals(ek)))) return e; if (eh < 0) { if (e instanceof ForwardingNode) { tab = ((ForwardingNode<K,V>)e).nextTable; continue outer; } else return e.find(h, k); } if ((e = e.next) == null) return null; } } } }
几个重要的值
/* *判断当前节点的下一节点指向的类型 */ static final int MOVED = -1; //指向的是ForwardingNode节点 static final int TREEBIN = -2; //指向的是tree节点 transient volatile Node<K,V>[] table; //hash桶,volatile修饰,保证可见性 private transient volatile Node<K,V>[] nextTable; //指向的下一个hash桶,volatile修饰,保证可见性 /* *表示当前表的状态,为负数的时候表示当前表正在初始化或扩容 *-1表示正在初始化,其他负数表示 -1+数值正在扩容的线程数 */ private transient volatile int sizeCtl 4000 ; //反向链表,不为空的时候总是2的幂数 private transient volatile CounterCell[] counterCells;
下面根据常用的流程来梳理其内部结构。首先是最常用的put(K key, V value)方法。put方法会调用putVal(key, value, false)方法。
final V putVal(K key, V value, boolean onlyIfAbsent) { //不允许key=null和value=null 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; 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; } //当前节点正在扩容,线程帮助扩容 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); return null; }
initTable()
private final Node<K,V>[] initTable() { Node<K,V>[] tab; int sc; //当表为空的时候进行循环 while ((tab = table) == null || tab.length == 0) { //当sizeCtl为负数时,表示当前表正在初始化或扩容,当前线程进行等待 if ((sc = sizeCtl) < 0) Thread.yield(); // lost initialization race; just spin else if (U.compareAndSwapInt(this, SIZECTL, sc, -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<?,?> ; table = tab = nt; sc = n - (n >>> 2); } } finally { sizeCtl = sc; } break; } } return tab; }
helpTransfer
(Node<K,V>[] tab, Node<K,V> f)
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) { Node<K,V>[] nextTab; int sc; if (tab != null && (f instanceof ForwardingNode) && (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) { //生成一个数字戳,防止ABA问题 int rs = resizeStamp(tab.length); while (nextTab == nextTable && table == tab && (sc = sizeCtl) < 0) { if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || sc == rs + MAX_RESIZERS || transferIndex <= 0) break; if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) { transfer(tab, nextTab); break; } } return nextTab; } return table; }
到这里,关于put的所有方法已经完成。
* get(Object key)*
public V get(Object key) { Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek; int h = spread(key.hashCode()); if ((tab = table) != null && (n = tab.length) > 0 && (e = tabAt(tab, (n - 1) & h)) != null) { if ((eh = e.hash) == h) { //在数组中 if ((ek = e.key) == key || (ek != null && key.equals(ek))) return e.val; } else if (eh < 0) //在小数组中 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; }
ConcurrentHashMap是一个比较难的类,看过之后还是一知半解,还需要不断学习。
相关文章推荐
- Java并发编程:并发容器之ConcurrentHashMap
- Java集合---ConcurrentHashMap原理分析
- HashMap,HashTable,ConcurrentHashMap,ConcurrentSkipListMap
- Java ConcurrentHashMap
- ConcurrentHashMap原理分析
- Java并发编程之ConcurrentHashMap
- Java集合---ConcurrentHashMap原理分析
- Java中的ConcurrentHashMap原理分析节选
- JAVA提高二十:CopyOnWriteArrayList&CopyOnWriteArraySet&ConcurrentHashMap介绍
- [JAVA修炼之路四]-集合(ConCurrentHashMap HashTable)
- JDK容器与并发—Map—ConcurrentHashMap
- JDK1.8之ConcurrentHashMap
- Java集合---ConcurrentHashMap原理分析
- ConcurrentHashMap原理详解
- 并发编程——ConcurrentHashMap#helpTransfer() 分析
- ConcurrentHashMap原理分析
- Java集合框架之ConcurrentHashMap
- 10016---ConcurrentHashMap原理分析
- at java.util.concurrent.ConcurrentHashMap.hash(ConcurrentHashMap.java:333)
- Java并发编程:并发容器之ConcurrentHashMap(转)