Java视频马士兵百度云，21道Java基础面试题及答案

（1）HashMap的源码：

1、HashMap中的hash函数实现：

详见：https://www.zhihu.com/question/20733617

2、HashMap源码解读

详见：http://blog.csdn.net/ll530304349/article/details/53056346

（2）ConcurrentHashMap的源码：

1、JDK1.7版本的实现

ConcurrentHashMap的锁分段技术：假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效的提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术。首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。

ConcurrentHashMap不允许Key或者Value的值为NULL

第一：Segment类

Put

将一个HashEntry放入到该Segment中，使用自旋机制，减少了加锁的可能性。

final V put(K key, int hash, V value, boolean onlyIfAbsent) {

   HashEntry<K,V> node = tryLock() ? null :

       scanAndLockForPut(key, hash, value); //如果加锁失败，则调用该方法

   V oldValue;

   try {

       HashEntry<K,V>[] tab = table;

       int index = (tab.length - 1) & hash; //同hashMap相同的哈希定位方式

       HashEntry<K,V> first = entryAt(tab, index);

       for (HashEntry<K,V> e = first;;) {

           if (e != null) {

       //若不为null，则持续查找，知道找到key和hash值相同的节点，将其value更新

               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 { //若头结点为null

               if (node != null) //在遍历key对应节点链时没有找到相应的节点

                   node.setNext(first);

                   //当前修改并不需要让其他线程知道，在锁退出时修改自然会

                   //更新到内存中,可提升性能

               else

                   node = new HashEntry<K,V>(hash, key, value, first);

               int c = count + 1;

               if (c > threshold && tab.length < MAXIMUM_CAPACITY)

                   rehash(node); //如果超过阈值，则进行rehash操作

               else

                   setEntryAt(tab, index, node);

               ++modCount;

               count = c;

               oldValue = null;

               break;

           }

       }

   } finally {

       unlock();

   }

   return oldValue;

} 

scanAndLockForPut

该操作持续查找key对应的节点链中是否已存在该节点，如果没有找到已存在的节点，则预创建一个新节点，并且尝试n次，直到尝试次数超出限制，才真正进入等待状态，即所谓的 自旋等待。

private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {

   //根据hash值找到segment中的HashEntry节点

   HashEntry<K,V> first = entryForHash(this, hash); //首先获取头结点

   HashEntry<K,V> e = first;

   HashEntry<K,V> node = null;

   int retries = -1; // negative while locating node

   while (!tryLock()) {  //持续遍历该哈希链

       HashEntry<K,V> f; // to recheck first below

       if (retries < 0) {

           if (e == null) {

               if (node == null) //若不存在要插入的节点，则创建一个新的节点

                   node = new HashEntry<K,V>(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值为－1，重新为尝试获取锁而自旋遍历*/

       else if ((retries & 1) == 0 &&

                (f = entryForHash(this, hash)) != first) {

           e = first