jdk1.7ConcurrentHashmap的底层原理

该方法主要是通过一个while(!tryLock()){}循环来不断地获取锁，如果此时锁仍然被其它线程持有，利用这个等待时间，顺便执行一下while循环体中的代码。循环体中的代码执行一次，retries（尝试获得锁的次数）变量就+1，同时判断table中有没有重复的值，没有就new一个新的HashEntry返回；有就不做操作，最终返回的是个null。

private HashEntry scanAndLockForPut(K key, int hash, V value) {//first是key对应table上的链表上的第一个元素HashEntry first = entryForHash(this, hash);HashEntry e = first;HashEntry node = null;int retries = -1; // negative while locating nodewhile (!tryLock()) {HashEntry f; // to recheck first below//retries<0说明在链表中既没有找到重复值，也没有遍历完链表遇到nullif (retries <0) {if (e == null) { //遍历到链表尾，new一个新的，键值和插入的一样if (node == null) // speculatively create nodenode = new HashEntry(hash, key, value, null);retries = 0;}else if (key.equals(e.key)) //遍历到重复的元素，不做其它操作retries = 0;else //否则遍历下一个节点 e = e.next;}//如果尝试获取锁的次数超过了最大次数，则当前线程进入休眠状态知道获得锁else if (++retries > MAX_SCAN_RETRIES) {lock();break;}//如果在这个过程中有新的线程插入了进来则重新执行该循环体代码，这里判断retries //奇偶性不太明白是什么意思else if ((retries & 1) == 0 &&(f = entryForHash(this, hash)) != first) {e = first = f; // re-traverse if entry changedretries = -1;}}return node;}

扩容，Segment的rehash方法

这里的rehash方法和Hashmap中的resize方法基本是一样的，都是先扩容两倍，再通过((newTableLentgh-1) & key.hash)求出节点在新table中的位置，接着用头插法把原table中的节点插入到新table中。不过Segment的rehash方法加入了一点优化判断，就是在遍历原table的时候，会用lastRun和lastIdx来记录每个单链表上的一个节点，这个节点及后面的节点在新table中的映射位置相同，这样在插入的时候直接插入lastRun即可，后面的元素也就跟着一起插入了。

一开始我不太理解为什么插入只有一句 newTable[lastIdx] = lastRun就完事了，如果之前lastIdx这个位置已经有节点存进来了，那这句代码不是会覆盖之前的节点吗？后来看到了rehash的方法说明：

Because we
             * are using power-of-two expansion, the elements from
             * each bin must either stay at same index, or move with a
             * power of two offset.

意思是oldTable中的节点插入到newTable中，节点的位置要么不变，要么都偏移一个2次幂数，这说明不会有其它位置上的单链表的节点会插入到newTable中的lastIdx位置。

private void rehash(HashEntry node) {HashEntry[] oldTable = table;int oldCapacity = oldTable.length;int newCapacity = oldCapacity <<1;threshold = (int)(newCapacity * loadFactor);HashEntry[] newTable =(HashEntry[]) new HashEntry[newCapacity];int sizeMask = newCapacity - 1;for (int i = 0; i e = oldTable[i];if (e != null) {HashEntry next = e.next;int idx = e.hash & sizeMask;if (next == null) // Single node on listnewTable[idx] = e;else { // Reuse consecutive sequence at same slot//下面代码是优化判断HashEntry lastRun = e;int lastIdx = idx;for (HashEntry 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//该链表上lastRun之前的节点正常插入，与Hashmap一致for (HashEntry p = e; p != lastRun; p = p.next) {V v = p.value;int h = p.hash;int k = h & sizeMask;HashEntry n = newTable[k];newTable[k] = new HashEntry(h, p.key, v, n);}}}}//添加我们要插入的数据int nodeIndex = node.hash & sizeMask; // add the new nodenode.setNext(newTable[nodeIndex]);newTable[nodeIndex] = node;table = newTable;}

ConcurrentHashmap的get方法

get方法与put和remove方法不同的是没有加锁解锁动作，但是也能实现并发同步的效果。原因是因为Segment中的HashEntry[] table使用了volatile关键字，同时HashEntry中的val和next字段也被volatile修饰，由于volatile能保证共享变量被修改后立刻对其它线程可见，所以能保证查询的无锁并发。table加volatile保证table扩容后是立即可见的，HashEntry的val加volatile保证节点被修改后是立即可见的，next加volatile保证节点被新增或删除是立刻可见的。详情可见：https://www.cnblogs.com/keeya/p/9632958.html。

public V get(Object key) {Segment s; // manually integrate access methods to reduce overheadHashEntry[] tab;int h = hash(key);//要查找的key属于segment[u]long u = (((h >>> segmentShift) & segmentMask) <)UNSAFE.getObjectVolatile(segments, u)) != null &&(tab = s.table) != null) {//找到key映射位置上的链表并遍历for (HashEntry e = (HashEntry) UNSAFE.getObjectVolatile(tab, ((long)(((tab.length - 1) & h)) <


ConcurrentHashmap的remove方法