终于，我读懂了所有Java集合——map篇(多线程)
多線程環(huán)境下的問(wèn)題
1.8中hashmap的確不會(huì)因?yàn)槎嗑€程put導(dǎo)致死循環(huán)（1.7代碼中會(huì)這樣子），但是依然有其他的弊端，比如數(shù)據(jù)丟失等等。因此多線程情況下還是建議使用ConcurrentHashMap。
?
數(shù)據(jù)丟失：當(dāng)多線程put的時(shí)候，當(dāng)index相同而又同時(shí)達(dá)到鏈表的末尾時(shí)，另一個(gè)線程put的數(shù)據(jù)會(huì)把之前線程put的數(shù)據(jù)覆蓋掉，就會(huì)產(chǎn)生數(shù)據(jù)丟失。
if ((e = p.next) == null) {p.next = newNode(hash, key, value, null);}Hashtable
Hashtable同樣是基于哈希表實(shí)現(xiàn)的，同樣每個(gè)元素是一個(gè)key-value對(duì)，其內(nèi)部也是通過(guò)單鏈表解決沖突問(wèn)題，容量不足（超過(guò)了閾值）時(shí)，同樣會(huì)自動(dòng)增長(zhǎng)。
Hashtable也是JDK1.0引入的類，是線程安全的，能用于多線程環(huán)境中。
Hashtable同樣實(shí)現(xiàn)了Serializable接口，它支持序列化，實(shí)現(xiàn)了Cloneable接口，能被克隆。
Hashtable 的容量增加邏輯是乘2+1，保證奇數(shù)。
在應(yīng)用數(shù)據(jù)分布在等差數(shù)據(jù)集合(如偶數(shù))上時(shí)，如果公差與桶容量有公約數(shù)n，則至少有(n-1)/n數(shù)量的桶是利用不到的。
hash to index
int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length;取與之后一定是一個(gè)非負(fù)數(shù)
0x7FFFFFFF is 0111 1111 1111 1111 1111 1111 1111 1111 : all 1 except the sign bit.
?(hash & 0x7FFFFFFF) will result in a positive integer.
?(hash & 0x7FFFFFFF) % tab.length will be in the range of the tab length.
ConcurrentHashMap
（底層是數(shù)組+鏈表/紅黑樹(shù)，基于CAS+synchronized）
JDK1.7前：分段鎖
基于currentLevel劃分出了多個(gè)Segment來(lái)對(duì)key-value進(jìn)行存儲(chǔ)，從而避免每次put操作都得鎖住整個(gè)數(shù)組。在默認(rèn)的情況下，最佳情況下可以允許16個(gè)線程并發(fā)無(wú)阻塞地操作集合對(duì)象，盡可能地減少并發(fā)時(shí)的阻塞現(xiàn)象。
put、remove會(huì)加鎖。get和containsKey不會(huì)加鎖。
計(jì)算size：在不加鎖的情況下遍歷所有的段，讀取其count以及modCount，這兩個(gè)屬性都是volatile類型的，并進(jìn)行統(tǒng)計(jì)，再遍歷一次所有的段，比較modCount是否有改變。如有改變，則再嘗試兩次機(jī)上動(dòng)作。
如執(zhí)行了三次上述動(dòng)作，仍然有問(wèn)題，則遍歷所有段，分別進(jìn)行加鎖，然后進(jìn)行計(jì)算，計(jì)算完畢后釋放所有鎖，從而完成計(jì)算動(dòng)作。
?
JDK1.8后：CAS+synchronized
bin是桶 bucket的意思
?
ConcurrentHashMap是延遲初始化的，只有在插入數(shù)據(jù)時(shí)，整個(gè)HashMap才被初始化為2的次方大小個(gè)桶（bin），每個(gè)bin包含哈希值相同的一系列Node（一般含有0或1個(gè)Node）。每個(gè)bin的第一個(gè)Node作為這個(gè)bin的鎖，Hash值為零或者負(fù)的將被忽略；
每個(gè)bin的第一個(gè)Node插入用到CAS原理，這是在ConcurrentHashMap中最常發(fā)生的操作，其余的插入、刪除、替換操作對(duì)bin中的第一個(gè)Node加鎖，進(jìn)行操作
ConcurrentHashMap的size()函數(shù)一般比較少用，同時(shí)為了提高增刪查改的效率，容器并未在內(nèi)部保存一個(gè)size值，而且采用每次調(diào)用size()函數(shù)時(shí)累加各個(gè)bin中Node的個(gè)數(shù)計(jì)算得到，而且這一過(guò)程不加鎖，即得到的size值不一定是最新的。
ConcurrentHashMap#Node
Node是最核心的內(nèi)部類，它包裝了key-value鍵值對(duì)，所有插入ConcurrentHashMap的數(shù)據(jù)都包裝在這里面。它與HashMap中的定義很相似，但是但是有一些差別：它對(duì)value和next屬性設(shè)置了volatile屬性；’它不允許調(diào)用setValue方法直接改變Node的value域；它增加了find方法輔助map.get()方法。
static class Node<K,V> implements Map.Entry<K,V> {final int hash;final K key;volatile V val; // value和next是volatile的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;} }?
ConcurrentHashMap#TreeNode
當(dāng)鏈表長(zhǎng)度過(guò)長(zhǎng)的時(shí)候，會(huì)轉(zhuǎn)換為TreeNode。但是與HashMap不相同的是，它并不是直接轉(zhuǎn)換為紅黑樹(shù)，而是把這些結(jié)點(diǎn)包裝成TreeNode放在TreeBin對(duì)象中，由TreeBin完成對(duì)紅黑樹(shù)的包裝。而且TreeNode在ConcurrentHashMap繼承自Node類，而并非HashMap中的繼承自LinkedHashMap.Entry<K,V>類，也就是說(shuō)TreeNode帶有next指針，這樣做的目的是方便基于TreeBin的訪問(wèn)。
ConcurrentHashMap#TreeBin
這個(gè)類并不負(fù)責(zé)包裝用戶的key、value信息，而是包裝的很多TreeNode節(jié)點(diǎn)。它代替了TreeNode的根節(jié)點(diǎn)，也就是說(shuō)在實(shí)際的ConcurrentHashMap“數(shù)組”中，存放的是TreeBin對(duì)象，而不是TreeNode對(duì)象，這是與HashMap的區(qū)別。另外這個(gè)類還帶有了讀寫鎖。
?
可以看到在構(gòu)造TreeBin節(jié)點(diǎn)時(shí)，僅僅指定了它的hash值為TREEBIN常量，這也就是個(gè)標(biāo)識(shí)位；同時(shí)也看到我們熟悉的紅黑樹(shù)構(gòu)造方法。
/*** TreeNodes used at the heads of bins. TreeBins do not hold user* keys or values, but instead point to list of TreeNodes and* their root. They also maintain a parasitic read-write lock* forcing writers (who hold bin lock) to wait for readers (who do* not) to complete before tree restructuring operations.*/ 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 lockStatestatic final int WRITER = 1; // set while holding write lockstatic final int WAITER = 2; // set when waiting for write lockstatic final int READER = 4; // increment value for setting read lock/*** Tie-breaking utility for ordering insertions when equal* hashCodes and non-comparable. We don't require a total* order, just a consistent insertion rule to maintain* equivalence across rebalancings. Tie-breaking further than* necessary simplifies testing a bit.*/static int tieBreakOrder(Object a, Object b) {int d;if (a == null || b == null ||(d = a.getClass().getName().compareTo(b.getClass().getName())) == 0)d = (System.identityHashCode(a) <= System.identityHashCode(b) ?-1 : 1);return d;}/*** Creates bin with initial set of nodes headed by b.*/TreeBin(TreeNode<K,V> b) {super(TREEBIN, null, null, null);this.first = b;TreeNode<K,V> r = null;for (TreeNode<K,V> x = b, next; x != null; x = next) {next = (TreeNode<K,V>)x.next;x.left = x.right = null;if (r == null) {x.parent = null;x.red = false;r = x;}else {K k = x.key;int h = x.hash;Class<?> kc = null;for (TreeNode<K,V> p = r;;) {int dir, ph;K pk = p.key;if ((ph = p.hash) > h)dir = -1;else if (ph < h)dir = 1;else if ((kc == null &&(kc = comparableClassFor(k)) == null) ||(dir = compareComparables(kc, k, pk)) == 0)dir = tieBreakOrder(k, pk);TreeNode<K,V> xp = p;if ((p = (dir <= 0) ? p.left : p.right) == null) {x.parent = xp;if (dir <= 0)xp.left = x;elsexp.right = x;r = balanceInsertion(r, x);break;}}}}this.root = r;assert checkInvariants(root);}}節(jié)點(diǎn)類型
hash值大于等于0，則是鏈表節(jié)點(diǎn)，Node
hash值為-1 ??MOVED，則是forwarding nodes，存儲(chǔ)nextTable的引用。只有table發(fā)生擴(kuò)容的時(shí)候，ForwardingNode才會(huì)發(fā)揮作用，作為一個(gè)占位符放在table中表示當(dāng)前節(jié)點(diǎn)為null或則已經(jīng)被移動(dòng)。
hash值為-2?? TREEBIN，則是紅黑樹(shù)根，TreeBin類型
hash值為-3?? RESERVED，則是reservation nodes，
static final int MOVED???? = -1; // hash for forwarding nodes
static final int TREEBIN?? = -2; // hash for roots of trees
static final int RESERVED? = -3; // hash for transient reservations
重要屬性
?
CAS
private static final sun.misc.Unsafe U;
Unsafe類的幾個(gè)CAS方法，可以原子性地修改對(duì)象的某個(gè)屬性值
/*** Atomically update Java variable to <tt>x</tt> if it is currently* holding <tt>expected</tt>.* @return <tt>true</tt> if successful*/ public final native boolean compareAndSwapObject(Object o, long offset,Object expected,Object x);/*** Atomically update Java variable to <tt>x</tt> if it is currently* holding <tt>expected</tt>.* @return <tt>true</tt> if successful*/ public final native boolean compareAndSwapInt(Object o, long offset,int expected,int x);/*** Atomically update Java variable to <tt>x</tt> if it is currently* holding <tt>expected</tt>.* @return <tt>true</tt> if successful*/ public final native boolean compareAndSwapLong(Object o, long offset,long expected,long x);/*** Fetches a reference value from a given Java variable, with volatile* load semantics. Otherwise identical to {@link #getObject(Object, long)}*/ public native Object getObjectVolatile(Object o, long offset);/*** Stores a reference value into a given Java variable, with* volatile store semantics. Otherwise identical to {@link #putObject(Object, long, Object)}*/ public native void??? putObjectVolatile(Object o, long offset, Object x);?Unsafe.getObjectVolatile可以直接獲取指定內(nèi)存的數(shù)據(jù)，保證了每次拿到數(shù)據(jù)都是最新的。
三個(gè)核心方法
ConcurrentHashMap定義了三個(gè)原子操作，用于對(duì)指定位置的節(jié)點(diǎn)進(jìn)行操作。正是這些原子操作保證了ConcurrentHashMap的線程安全。????
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); }初始化
對(duì)于ConcurrentHashMap來(lái)說(shuō)，調(diào)用它的構(gòu)造方法僅僅是設(shè)置了一些參數(shù)而已。而整個(gè)table的初始化是在向ConcurrentHashMap中插入元素的時(shí)候發(fā)生的。如調(diào)用put、computeIfAbsent、compute、merge等方法的時(shí)候，調(diào)用時(shí)機(jī)是檢查table==null。
初始化方法主要應(yīng)用了關(guān)鍵屬性sizeCtl 如果這個(gè)值<0，表示其他線程正在進(jìn)行初始化，就放棄這個(gè)操作。在這也可以看出ConcurrentHashMap的初始化只能由一個(gè)線程完成。如果獲得了初始化權(quán)限，就用CAS方法將sizeCtl置為-1，防止其他線程進(jìn)入。初始化數(shù)組后，將sizeCtl的值改為0.75*n。
private final Node<K,V>[] initTable() {Node<K,V>[] tab; int sc;while ((tab = table) == null || tab.length == 0) {if ((sc = sizeCtl) < 0)Thread.yield(); // lost initialization race; just spin// 利用CAS方法把sizectl的值置為-1 表示本線程正在進(jìn)行初始化?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<?,?>[n];table = tab = nt;// 相當(dāng)于0.75*n 設(shè)置一個(gè)擴(kuò)容的閾值?sc = n - (n >>> 2);}} finally {sizeCtl = sc;}break;}}return tab; }spread（hash）
h是某個(gè)對(duì)象的hashCode返回值
static final int spread(int h) {return (h ^ (h >>> 16)) & HASH_BITS; }static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash類似于Hashtable+HashMap的hash實(shí)現(xiàn)，Hashtable中也是和一個(gè)魔法值取與，保證結(jié)果一定為正數(shù)；HashMap中也是將hashCode與其移動(dòng)低n位的結(jié)果再取異或，保證了對(duì)象的hashCode的高16位的變化能反應(yīng)到低16位中，
成員變量
@sun.misc.Contended static final class CounterCell {volatile long value;CounterCell(long x) { value = x; } }/*** Base counter value, used mainly when there is no contention,* but also as a fallback during table initialization* races. Updated via CAS.*/ private transient volatile long baseCount;/*** 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;每個(gè)CounterCell都對(duì)應(yīng)一個(gè)bucket，CounterCell中的long值就是對(duì)應(yīng)bucket的binCount。
計(jì)算總大小就是將所有bucket的binCount求和，而每個(gè)binCount都存儲(chǔ)在CounterCell#value中，每當(dāng)put或者remove時(shí)都會(huì)更新節(jié)點(diǎn)所在bucket對(duì)應(yīng)的CounterCell#value。
size()
沒(méi)有直接返回baseCount 而是統(tǒng)計(jì)一次這個(gè)值，而這個(gè)值其實(shí)也是一個(gè)大概的數(shù)值，因此可能在統(tǒng)計(jì)的時(shí)候有其他線程正在執(zhí)行插入或刪除操作。
public int size() {long n = sumCount();return ((n < 0L) ? 0 :(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :(int)n); }在baseCount基礎(chǔ)上再加上所有counterCell的值求和。
?
而在addCount時(shí)，會(huì)先嘗試CAS更新baseCount，如果有沖突，則再嘗試CAS更新隨機(jī)的一個(gè)counterCell中的value，這樣求和就是正確的size了。
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)// 所有counter的值求和?sum += a.value;}}return sum; }put
（若bucket第一個(gè)結(jié)點(diǎn)插入則使用CAS，否則加鎖）
public V put(K key, V value) {return putVal(key, value, false); }整體流程就是首先定義不允許key或value為null的情況放入 。對(duì)于每一個(gè)放入的值，首先利用spread方法對(duì)key的hashcode進(jìn)行一次hash計(jì)算，由此來(lái)確定這個(gè)值在table中的位置。
1）如果這個(gè)位置是空的，那么直接放入，而且不需要加鎖操作。
2）如果這個(gè)位置存在結(jié)點(diǎn)，說(shuō)明發(fā)生了hash碰撞，首先判斷這個(gè)節(jié)點(diǎn)的類型。
a）如果是MOVED節(jié)點(diǎn)，則表示正在擴(kuò)容，幫助進(jìn)行擴(kuò)容
b）如果是鏈表節(jié)點(diǎn)(hash >=0）,則得到的結(jié)點(diǎn)就是hash值相同的節(jié)點(diǎn)組成的鏈表的頭節(jié)點(diǎn)。需要依次向后遍歷確定這個(gè)新加入的值所在位置。如果遇到hash值與key值都與新加入節(jié)點(diǎn)是一致的情況，則只需要更新value值即可。否則依次向后遍歷，直到鏈表尾插入這個(gè)結(jié)點(diǎn)。 如果加入這個(gè)節(jié)點(diǎn)以后鏈表長(zhǎng)度大于8，就把這個(gè)鏈表轉(zhuǎn)換成紅黑樹(shù)。
c）如果這個(gè)節(jié)點(diǎn)的類型已經(jīng)是樹(shù)節(jié)點(diǎn)的話，直接調(diào)用樹(shù)節(jié)點(diǎn)的插入方法進(jìn)行插入新的值。
3）addCount 增加計(jì)數(shù)值
/** Implementation for put and putIfAbsent */ final V putVal(K key, V value, boolean onlyIfAbsent) {if (key == null || value == null) throw new NullPointerException();int hash = spread(key.hashCode());int binCount = 0;// 死循環(huán)，只有插入成功時(shí)才會(huì)跳出for (Node<K,V>[] tab = table;;) {Node<K,V> f; int n, i, fh;if (tab == null || (n = tab.length) == 0)// table為空則初始化（延遲初始化）tab = initTable();else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {// hash to index后正好為空，則CAS放入；如果失敗那么進(jìn)入下次循環(huán)繼續(xù)嘗試if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null)))break;?????????????????? // no lock when adding to empty bin}// 如果index處非空，且hash為MOVED（表示該節(jié)點(diǎn)是ForwardingNode），則表示有其它線程正在擴(kuò)容，則一起進(jìn)行擴(kuò)容操作。???????else if ((fh = f.hash) == MOVED)tab = helpTransfer(tab, f);// 如果index處非空，且為鏈表節(jié)點(diǎn)或樹(shù)節(jié)點(diǎn)else {V oldVal = null;// 對(duì)某個(gè)bucket上執(zhí)行添加操作僅需要鎖住第一個(gè)Node即可（可以保證不會(huì)多線程同時(shí)對(duì)某個(gè)bucket進(jìn)行寫入）synchronized (f) {if (tabAt(tab, i) == f) {// 1) 如果是鏈表節(jié)點(diǎn)，那么插入到鏈表中if (fh >= 0) {// binCount是該bucket中元素個(gè)數(shù)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;}}}// 2)如果是紅黑樹(shù)樹(shù)根，那么插入到紅黑樹(shù)中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;}}}}// 插入節(jié)點(diǎn)/釋放鎖之后，如果大小合適調(diào)整為紅黑樹(shù)，那么將鏈表轉(zhuǎn)為紅黑樹(shù)if (binCount != 0) {if (binCount >= TREEIFY_THRESHOLD)treeifyBin(tab, i);if (oldVal != null)return oldVal;break;}}}// 將當(dāng)前ConcurrentHashMap的元素?cái)?shù)量+1 ，如果超過(guò)閾值，那么進(jìn)行擴(kuò)容addCount(1L, binCount);return null; }?treeifyBin
（有鎖，數(shù)組較小則擴(kuò)容，較大則轉(zhuǎn)為紅黑樹(shù)
擴(kuò)容
tryPresize
tryPresize在putAll以及treeifyBin中調(diào)用
addCount
x=1，check=bucketCount
private final void addCount(long x, int check) {// 計(jì)數(shù)值加x// 利用CAS方法更新baseCount的值??CounterCell[] as; long b, s;if ((as = counterCells) != null ||!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {// 如果CAS更新baseCount失敗或者counterCells不為空，那么嘗試CAS更新當(dāng)前線程的hashCode對(duì)應(yīng)的bucket的valueCounterCell a; long v; int m;boolean uncontended = true;if (as == null || (m = as.length - 1) < 0 ||(a = as[ThreadLocalRandom.getProbe() & m]) == null ||!(uncontended =U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {// 如果兩次CAS都失敗了，那么調(diào)用fullAddCount方法fullAddCount(x, uncontended);return;}if (check <= 1)return;s = sumCount();}// 以上與擴(kuò)容無(wú)關(guān)，如果check值大于等于0 則需要檢查是否需要進(jìn)行擴(kuò)容操作?if (check >= 0) {Node<K,V>[] tab, nt; int n, sc;while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&(n = tab.length) < MAXIMUM_CAPACITY) {int rs = resizeStamp(n);// 如果sizeCtl是小于0的，說(shuō)明有其他線程正在執(zhí)行擴(kuò)容操作，nextTable一定不為空if (sc < 0) {if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||transferIndex <= 0)break;// 協(xié)助擴(kuò)容if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))transfer(tab, nt);}// 當(dāng)前線程是唯一的或是第一個(gè)發(fā)起擴(kuò)容的線程? 此時(shí)nextTable=null else if (U.compareAndSwapInt(this, SIZECTL, sc,(rs << RESIZE_STAMP_SHIFT) + 2))// 發(fā)起擴(kuò)容transfer(tab, null);s = sumCount();}} }?
transfer
當(dāng)table容量不足的時(shí)候，即table的元素?cái)?shù)量達(dá)到容量閾值sizeCtl，需要對(duì)table進(jìn)行擴(kuò)容。 整個(gè)擴(kuò)容分為兩部分：
1）構(gòu)建一個(gè)nextTable，大小為table的兩倍。
2）把table的數(shù)據(jù)復(fù)制到nextTable中。
這兩個(gè)過(guò)程在單線程下實(shí)現(xiàn)很簡(jiǎn)單，但是ConcurrentHashMap是支持并發(fā)插入的，擴(kuò)容操作自然也會(huì)有并發(fā)的出現(xiàn)，這種情況下，第二步可以支持節(jié)點(diǎn)的并發(fā)復(fù)制，這樣性能自然提升不少，但實(shí)現(xiàn)的復(fù)雜度也上升了一個(gè)臺(tái)階。
先看第一步，構(gòu)建nextTable，毫無(wú)疑問(wèn)，這個(gè)過(guò)程只能有單個(gè)線程進(jìn)行nextTable的初始化。
通過(guò)Unsafe.compareAndSwapInt修改sizeCtl值，保證只有一個(gè)線程能夠初始化nextTable，擴(kuò)容后的數(shù)組長(zhǎng)度為原來(lái)的兩倍。
節(jié)點(diǎn)從table移動(dòng)到nextTable，大體思想是遍歷、復(fù)制的過(guò)程。
1）首先根據(jù)運(yùn)算得到需要遍歷的次數(shù)i，然后利用tabAt方法獲得i位置的元素f，初始化一個(gè)ForwardingNode實(shí)例fwd。
2）如果f==null，則在table中的i位置放入fwd，這個(gè)過(guò)程是采用
Unsafe.compareAndSwapObjectf方法實(shí)現(xiàn)的，很巧妙的實(shí)現(xiàn)了節(jié)點(diǎn)的并發(fā)移動(dòng)。
3）如果f是鏈表的頭節(jié)點(diǎn)，就構(gòu)造一個(gè)反序鏈表，把他們分別放在nextTable的i和i+n的位置上，移動(dòng)完成，采用Unsafe.putObjectVolatile方法給table原位置賦值fwd。
4）如果f是TreeBin節(jié)點(diǎn)，也做一個(gè)反序處理，并判斷是否需要untreeify，把處理的結(jié)果分別放在nextTable的i和i+n的位置上，移動(dòng)完成，同樣采用Unsafe.putObjectVolatile方法給table原位置賦值fwd。
5）遍歷過(guò)所有的節(jié)點(diǎn)以后就完成了復(fù)制工作，把table指向nextTable，并更新sizeCtl為新數(shù)組大小的0.75倍 ，擴(kuò)容完成。
?
在多線程環(huán)境下，ConcurrentHashMap用兩點(diǎn)來(lái)保證正確性：ForwardingNode和synchronized。當(dāng)一個(gè)線程遍歷到的節(jié)點(diǎn)如果是ForwardingNode，則繼續(xù)往后遍歷，如果不是，則將該節(jié)點(diǎn)加鎖，防止其他線程進(jìn)入，完成后設(shè)置ForwardingNode節(jié)點(diǎn)，以便要其他線程可以看到該節(jié)點(diǎn)已經(jīng)處理過(guò)了，如此交叉進(jìn)行，高效而又安全。
?
get（無(wú)鎖）
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) {// bucket中第一個(gè)結(jié)點(diǎn)就是我們要找的，直接返回if ((ek = e.key) == key || (ek != null && key.equals(ek)))return e.val;}else if (eh < 0)// bucket中第一個(gè)結(jié)點(diǎn)是紅黑樹(shù)根，則調(diào)用find方法去找return (p = e.find(h, key)) != null ? p.val : null;// bucket中第一個(gè)結(jié)點(diǎn)是鏈表，則遍歷鏈表查找while ((e = e.next) != null) {if (e.hash == h &&((ek = e.key) == key || (ek != null && key.equals(ek))))return e.val;}}return null; }untreeify（無(wú)鎖）
remove（有鎖）
分段鎖實(shí)現(xiàn)
采用 Segment + HashEntry的方式進(jìn)行實(shí)現(xiàn)
put
當(dāng)執(zhí)行 put方法插入數(shù)據(jù)時(shí)，根據(jù)key的hash值，在 Segment數(shù)組中找到相應(yīng)的位置，如果相應(yīng)位置的 Segment還未初始化，則通過(guò)CAS進(jìn)行賦值，接著執(zhí)行 Segment對(duì)象的 put方法通過(guò)加鎖機(jī)制插入數(shù)據(jù)，實(shí)現(xiàn)如下：
場(chǎng)景：線程A和線程B同時(shí)執(zhí)行相同 Segment對(duì)象的 put方法
1、線程A執(zhí)行 tryLock()方法成功獲取鎖，則把 HashEntry對(duì)象插入到相應(yīng)的位置；
2、線程B獲取鎖失敗，則執(zhí)行 scanAndLockForPut()方法，在 scanAndLockForPut方法中，會(huì)通過(guò)重復(fù)執(zhí)行 tryLock()方法嘗試獲取鎖，在多處理器環(huán)境下，重復(fù)次數(shù)為64，單處理器重復(fù)次數(shù)為1，當(dāng)執(zhí)行 tryLock()方法的次數(shù)超過(guò)上限時(shí)，則執(zhí)行 lock()方法掛起線程B；
3、當(dāng)線程A執(zhí)行完插入操作時(shí)，會(huì)通過(guò) unlock()方法釋放鎖，接著喚醒線程B繼續(xù)執(zhí)行；
size
因?yàn)?ConcurrentHashMap是可以并發(fā)插入數(shù)據(jù)的，所以在準(zhǔn)確計(jì)算元素時(shí)存在一定的難度，一般的思路是統(tǒng)計(jì)每個(gè) Segment對(duì)象中的元素個(gè)數(shù)，然后進(jìn)行累加，但是這種方式計(jì)算出來(lái)的結(jié)果并不一樣的準(zhǔn)確的，因?yàn)樵谟?jì)算后面幾個(gè) Segment的元素個(gè)數(shù)時(shí)，已經(jīng)計(jì)算過(guò)的 Segment同時(shí)可能有數(shù)據(jù)的插入或則刪除。
先采用不加鎖的方式，連續(xù)計(jì)算元素的個(gè)數(shù)，最多計(jì)算3次： 1、如果前后兩次計(jì)算結(jié)果相同，則說(shuō)明計(jì)算出來(lái)的元素個(gè)數(shù)是準(zhǔn)確的； 2、如果前后兩次計(jì)算結(jié)果都不同，則給每個(gè) Segment進(jìn)行加鎖，再計(jì)算一次元素的個(gè)數(shù)；
ConcurrentSkipListMap
ConcurrentSkipListMap有幾個(gè)ConcurrentHashMap 不能比擬的優(yōu)點(diǎn)：
1、ConcurrentSkipListMap 的key是有序的。
2、ConcurrentSkipListMap 支持更高的并發(fā)。ConcurrentSkipListMap 的存取時(shí)間是log（N），和線程數(shù)幾乎無(wú)關(guān)。也就是說(shuō)在數(shù)據(jù)量一定的情況下，并發(fā)的線程越多，ConcurrentSkipListMap越能體現(xiàn)出他的優(yōu)勢(shì)。
?
SkipList 跳表：
跳表是平衡樹(shù)的一種替代的數(shù)據(jù)結(jié)構(gòu)，但是和紅黑樹(shù)不相同的是，跳表對(duì)于樹(shù)的平衡的實(shí)現(xiàn)是基于一種隨機(jī)化的算法的，這樣也就是說(shuō)跳表的插入和刪除的工作是比較簡(jiǎn)單的。
下面來(lái)研究一下跳表的核心思想：
先從鏈表開(kāi)始，如果是一個(gè)簡(jiǎn)單的鏈表，那么我們知道在鏈表中查找一個(gè)元素I的話，需要將整個(gè)鏈表遍歷一次。
?
?如果是說(shuō)鏈表是排序的，并且節(jié)點(diǎn)中還存儲(chǔ)了指向前面第二個(gè)節(jié)點(diǎn)的指針的話，那么在查找一個(gè)節(jié)點(diǎn)時(shí)，僅僅需要遍歷N/2個(gè)節(jié)點(diǎn)即可。
這基本上就是跳表的核心思想，其實(shí)也是一種通過(guò)“空間來(lái)?yè)Q取時(shí)間”的一個(gè)算法，通過(guò)在每個(gè)節(jié)點(diǎn)中增加了向前的指針，從而提升查找的效率。
Map實(shí)現(xiàn)類之間的區(qū)別
HashMap與ConcurrentHashMap區(qū)別
1）前者允許key或value為null，后者不允許
2）前者不是線程安全的，后者是
HashMap、TreeMap與LinkedHashMap區(qū)別
1）HashMap遍歷時(shí)，取得數(shù)據(jù)的順序是完全隨機(jī)的；
TreeMap可以按照自然順序或Comparator排序；
LinkedHashMap可以按照插入順序或訪問(wèn)順序排序，且get的效率（O(1)）比TreeMap（O(logn)）更高。
2）HashMap底層基于哈希表，數(shù)組+鏈表/紅黑樹(shù)；
TreeMap底層基于紅黑樹(shù)
LinkedHashMap底層基于HashMap與環(huán)形雙向鏈表
3）就get和put效率而言，HashMap是最高的，LinkedHashMap次之，TreeMap最次。
HashMap與Hashtable區(qū)別
1. 擴(kuò)容策略：Hashtable在不指定容量的情況下的默認(rèn)容量為11，而HashMap為16，Hashtable不要求底層數(shù)組的容量一定要為2的整數(shù)次冪（*2+1），而HashMap則要求一定為2的整數(shù)次冪（*2）。
2. 允許null：Hashtable中key和value都不允許為null，而HashMap中key和value都允許為null（key只能有一個(gè)為null，而value則可以有多個(gè)為null）。
3. 線程安全：前者不是線程安全的，后者是；
ConcurrentHashMap、Collections.synchronizedMap與Hashtable的異同
它們都是同步Map，但三者實(shí)現(xiàn)同步的機(jī)制不同；后兩者都是簡(jiǎn)單地在方法上加synchronized實(shí)現(xiàn)的，鎖的粒度較大；前者是基于CAS和synchronized實(shí)現(xiàn)的，鎖的粒度較小，大部分都是lock-free無(wú)鎖實(shí)現(xiàn)同步的。
ConcurrentHashMap還提供了putIfAbsent同步方法。
總結(jié)
以上是生活随笔為你收集整理的终于，我读懂了所有Java集合——map篇(多线程)的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。
- 上一篇： 橙白oj18训练作业2-题解、代码
- 下一篇： 终于，我读懂了所有Java集合——Lis