HashMap核心源码解析之Jdk1.7ConcurrenHashMap

Jdk1.7ConcurrenHashMap

---

---

前言

HashTable是通过在函数上加synchronized，即在HashTable对象上加锁，实现的线程安全，但是这种方式，虽然实现了线程安全，但是同时刻只能put或者get，效率非常低。
ConcurrentHashMap是由Segment和Segment内的HashEntry数组组成，类似于二维数组，HashEntry的长度是根据，ConcurrentHashMap和隔离级别来进行计算的，隔离级别代表的是Segment数组的长度。扩容是Segment对象的HashEntry扩容。是通过UNSELF直接从内存中获取最新的对象，而不是从线程缓存中获取以及put上加锁实现的，put操作的时候首先尝试加锁tryLock，直到加锁成功之后，执行put操作。ConcurrentHashMap不支持key或者value为空的Entry

// 有点二维数组的意思。
ConcurrentHashMap:
	Segment<K,V>[] segments
Segment:
	 transient volatile HashEntry<K,V>[] table;	

---

一、 重要属性

（0） concurrencyLevel；并发级别，就是Segment数组的长度
（1）initialCapacity；初始化的容量；代表的是Map的容量大小;注意不是Segment数组的长度也不是Segment里面HashEntry的长度，HashEntry的长度是initialCapacity / concurrencyLevel靠计算出来的。
（2）MAX_SEGMENTS = 1 << 16； 最大的并发级别为2的16次方，Segment数组的长度最多是2的16次方
（3）MIN_SEGMENT_TABLE_CAPACITY = 2; Segment里面HashEntry的长度最小是2
（4）segmentShift = 32 - sshift；sshift是“大于等于concurrencyLevel的2的幂次方数” 的那个幂，然后segmentShift 等于32减去那个幂，用来做hashcode的映射，ConcurrentHashMap里面不是对低位取与，而是对高位取与。
（5）this.segmentMask = ssize - 1；ssize是计算出的大于等于concurrencyLevel的2的幂次方数，segmentMask的作用还是取与代替取余。
（6）transient int modCount; HashEntry数组的修改次数，ConcurrentHashMap.Segment的HashEntry数组的修改次数
（7）MAX_SCAN_RETRIES = Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1; 在扫描还有尝试加锁的函数中，尝试加锁的最大次数。
（8）MAXIMUM_CAPACITY= 1 << 30； 最大容量
（9）DEFAULT_LOAD_FACTOR = 0.75f； 默认加载因子0.75
（10）final Segment<K,V>[] segments; HashMap的底层实现隔离级别数组
（11）float loadFactor; HashEntry的加载因子
（12）transient int hashSeed ; Hash种子;没有指定虚拟机的参数的话，就是0
（13）int threshold; 阈值，即下次扩容的大小，计算公式是 (capacity * load factor)
（14）transient int modCount; HashMap的修改次数

二、 构造函数

ConcurrentHashMap是由Segment数组以及Segment对象的HashEntry数组组成，在ConcurrentHashMap构造函数里面初始化了Segment数组，但是为了保证Segment的一些信息得以保留，所以将Segment数组的第一个元素作为原型对象，因为只给第一个元素创建了对象，所以当Segment的其他位置进行put操作时，会以Segment数组的一个元素为原型创建其他位置的元素。

 public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        if (concurrencyLevel > MAX_SEGMENTS)
            concurrencyLevel = MAX_SEGMENTS;
        // Find power-of-two sizes best matching arguments
        int sshift = 0;
        int ssize = 1;
        // 找到大于等于concurrencyLevel的2的幂次方数
        // 为什么非得是2的幂次方数，原理其实和HashMap是一样的，如果是2的幂次方数，可以直接求出来HashCode & (ssize - 1)。计算上比较方便
        // 也就是  0000 1101 & 0000 1111 = 0000 1101；因为后面四位都1，所以做与运算，就是相当于截取了后面四位
        // sshift其实算的是   大于等于concurrencyLevel的2的幂次方数  的那个幂
        while (ssize < con currencyLevel) {
            ++sshift;
            ssize <<= 1;
        }
        this.segmentShift = 32 - sshift;
        this.segmentMask = ssize - 1;
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
            
        // 由此可见Segment里面数组的长度是根据initialCapacity和并发级别算出来的
        int c = initialCapacity / ssize;
        // 如果算出来的是小数，就+1，如果是17/16的情况，就将c的值+1.
        if (c * ssize < initialCapacity)
            ++c;
        
        int cap = MIN_SEGMENT_TABLE_CAPACITY;
        // 如果算出来的c小于2的时候，cap的值就是2
        // 如果大于2的话，同样的道理去算大于cap的2的幂次方数。
        while (cap < c)
            cap <<= 1;

        // 创建segment数组，并且初始化segment数组元素，因为如果不初始化的话，数组元素是NULL;必须给其赋值才能使用。要不然put的时候new Segment的时候更麻烦，因为还得计算HashEntry的大小，那样更麻烦。
        // 加载因子默认还是0.75，阈值是cap*loadFactor
        Segment<K,V> s0 =
            new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                             (HashEntry<K,V>[])new HashEntry[cap]);
        Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
        // 相当与创建了s0一个模板对象，因为segment数组元素的初始值应该都是一样的。
        UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
        this.segments = ss;
    }

三、 put

put肯定是先计算hashcode，然后根据hashcode找到对应的segment数组下标，然后在找到segment对象内的HashEntry数组下标，然后进行put。ConcurrentHashMap不支持key和value为空。put操作里面多次加锁，在执行put函数的时候尝试加锁，如果加锁失败的话。就进入scanAndLockForPut方法，扫描需要插入位置对应的单链表，但是遍历貌似没有一样，主要作用还是加锁，加锁成功之后返回到put函数，然后遍历单链表，执行插入操作。如果在插入的时候发现HashEntry的容量已经超过了阈值，就去执行rehash操作，执行扩容；执行扩容的时候，认为单链表中会出现相邻几个元素hash值是相同的情况，就找到这种情况的最后一段（类似于蜘蛛纸牌），然后将该段直接拷贝到新的数组结点上。然后拷贝从头部到该段开始的剩余部分。

 public V put(K key, V value) {
        Segment<K,V> s;
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key);
        // 如果并发级别为16的话，由构造函数可知sshift = 4，然后segmentShift=32-4 =28
        // hash >>> segmentShift 将hashcode右移28位，其实相当于取了高4位的hashcode。
        // 取与之后得到hashcode对应在segment数组中的下标，然后得到该索引下的数组元素，如果该元素为空，那就利用构造函数里面创建的原型对象赋值到该元素位置；然后在该segment对象上put进元素。
        int j = (hash >>> segmentShift) & segmentMask;
        // j << SSHIFT；SSHIFT代表的是
        if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
            s = ensureSegment(j);
        return s.put(key, hash, value, false);
}
    
// 根据segment数组的[0]第一个元素创建Segment对象，赋值给segment数组的指定位置元素。
private Segment<K,V> ensureSegment(int k) {
        final Segment<K,V>[] ss = this.segments;
        long u = (k << SSHIFT) + SBASE; // raw offset
        Segment<K,V> seg;
        
        // 判断此时别的线程是否已经生成了segment对象
        if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
        	// 如果没有线程生成的话，拿到ss[0]的原形对象
            Segment<K,V> proto = ss[0]; // 将ss[0]作为原型对象
            int cap = proto.table.length;
            float lf = proto.loadFactor;
            int threshold = (int)(cap * lf);
            HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
            if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                == null) { // recheck
                Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
                // 循环判断是否该segment对象已经由其他线程生成。 如果没有其他线程生成的话，启用CAS进行赋值，直到赋值成功。
                // 这样做就是安全，如果第一次CAS失败了，再次执行循环的时候可能就不满足条件了，就退出                
                while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                       == null) {
                    // 如果别的线程没有生成，则用CAS进行生成。
                    if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
                        break;
                }
            }
        }
        return seg;
}

// Segment的put方法，会首先加锁。
// 当前线程想要往hashmap中put元素，首先应该尝加锁，如果加锁失败的话，就进入scanAndLockForPut函数，直到加到锁
// tryLock不阻塞，获取不到就立马返回；lock是阻塞的，直到获取到锁
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
			// 尝试获取锁。没有获取到的话，就执行scanAndLockForPut尝试加锁。
            HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);
            // 当前线程已经获取了锁
            V oldValue;
            try {
                HashEntry<K,V>[] tab = table;
                // 根据hashcode找到HashEntry数组内指定的索引。
                int index = (tab.length - 1) & hash;
                // 根据指定的索引找到对应的Enrty
                HashEntry<K,V> first = entryAt(tab, index);
                // 循环遍历Entry数组
                for (HashEntry<K,V> e = first;;) {
                    if (e != null) {
                        K k;
                        // 在单链表中找到和插入的key相同的元素
                        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 {
                    	// e == null有两种情况
                    	// 1、一开始first为空
                    	// 2、把单链表遍历了一遍都没有发现可以修改的key
                    	// 头插法
                        if (node != null)
                            node.setNext(first);
                        else
                            node = new HashEntry<K,V>(hash, key, value, first);
                        int c = count + 1;
                        // 如果插入该元素之后发现当前HashEntry数组的长度已经大于了阈值，就reshsh
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                            rehash(node);
                        else
                            setEntryAt(tab, index, node); // 线程安全的方法
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
            	// 执行完之后解锁。
                unlock();
            }
            return oldValue;
}
// 扫描并且加锁 为了put
// 既然我加不到锁，那么我就不断的tryLock，因为tryLock不阻塞，所以我可以在这个空闲时间，做点事情
// 做的事情就是遍历指定索引的数组元素的单链表，但是主要还是为了加锁，其他的遍历的逻辑没有含义，因为在主函数里面又再次遍历了单链表。
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
            HashEntry<K,V> first = entryForHash(this, hash);
            HashEntry<K,V> e = first;
            HashEntry<K,V> node = null;
            int retries = -1; // retries < 0 代表正在遍历单链表
            while (!tryLock()) {
                HashEntry<K,V> f; // to recheck first below
                if (retries < 0) {
                    if (e == null) {
                    	// 如果遍历到了尾结点，还是没有找到重复key的结点，就代表遍历结束
                    	// 创建新的结点，但是这个new没啥含义，在主函数里面又检查了一次
                        if (node == null) // speculatively create node
                            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;
                }
                // 每隔一次判断一下，单链表的头结点和当前线程保存的头结点是否一样
                else if ((retries & 1) == 0 &&
                         (f = entryForHash(this, hash)) != first) {
                    // 如果不一样了，就将最新的单链表头结点保存一下，同时让retries = -1，代表重新开始遍历单链表
                    e = first = f; // re-traverse if entry changed
                    retries = -1;
                }
            }
            return node;
        }


// 线程安全的方法，使用的UNSAFE方法。直接修改的内存中的值
static final <K,V> void setEntryAt(HashEntry<K,V>[] tab, int i,
                                       HashEntry<K,V> e) {
        UNSAFE.putOrderedObject(tab, ((long)i << TSHIFT) + TBASE, e);
}

private void rehash(HashEntry<K,V> node) {
    HashEntry<K,V>[] oldTable = table;
    int oldCapacity = oldTable.length;
    int newCapacity = oldCapacity << 1;
    threshold = (int)(newCapacity * loadFactor);
    HashEntry<K,V>[] newTable =
        (HashEntry<K,V>[]) new HashEntry[newCapacity];
    int sizeMask = newCapacity - 1;
    for (int i = 0; i < oldCapacity ; i++) {
        HashEntry<K,V> e = oldTable[i];
        if (e != null) {
            HashEntry<K,V> next = e.next;
            int idx = e.hash & sizeMask;
            if (next == null)   //  Single node on list
                newTable[idx] = e;
            else { // Reuse consecutive sequence at same slot
                HashEntry<K,V> lastRun = e;
                int lastIdx = idx;
                // 这里的扩容有一个假设，就是一个单链表的若干个相邻元素rehash之后可能还是在同一个单链表，所以基于这个前提，遍历单链表，直到找到链表从最远的位置到尾结点的重复hash元素，然后将其按照一个子单链表的方式添加到新的hash数组。
                // 类似于蜘蛛纸牌
                for (HashEntry<K,V> last = next;
                     last != null;
                     last = last.next) {
                    int k = last.hash & sizeMask;
                    if (k != lastIdx) {
                        lastIdx = k;
                        lastRun = last;
                    }
                }
                // lastRun就是从尾部向前，最远的hashcode重复的单链表的起始结点。
                newTable[lastIdx] = lastRun;
                // 完成从头结点开始到lastRun的其他节点的迁移
                for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
                    V v = p.value;
                    int h = p.hash;
                    int k = h & sizeMask;
                    HashEntry<K,V> n = newTable[k];
                    // 头插法。
                    newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
                }
            }
        }
    }
    int nodeIndex = node.hash & sizeMask; // add the new node
    node.setNext(newTable[nodeIndex]);
    newTable[nodeIndex] = node;
    table = newTable;
}

四、 Get

get没有加锁，就是利用UNSAFE直接从内存中那最新的数据。

public V get(Object key) {
      Segment<K,V> s; // manually integrate access methods to reduce overhead
      HashEntry<K,V>[] tab;
      int h = hash(key);
      // 得到指定key对应的segment数组的索引
      long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
      // 得到内存中的指定索引的segment数组元素
      if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
          (tab = s.table) != null) {
          for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                   (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
               e != null; e = e.next) {
              K k;
              if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                  return e.value;
          }
      }
      return null;
  }

五、remove

remove操作也是一样的，就是利用Unself直接从内存中获取Segment数组元素，然后执行删除方法删除HashEntry元素。

  public V remove(Object key) {
        int hash = hash(key);
        Segment<K,V> s = segmentForHash(hash);
        return s == null ? null : s.remove(key, hash, null);
    }

五、size

size方法是遍历Segment数组两次（每次遍历都将segment数组的所有元素加锁），如果两次的modCount不一样的话，就一直循环，直到找到连续两次的modCount一样的情况。

public int size() {
      // Try a few times to get accurate count. On failure due to
      // continuous async changes in table, resort to locking.
      final Segment<K,V>[] segments = this.segments;
      int size;
      boolean overflow; // true if size overflows 32 bits
      long sum;         // sum of modCounts
      long last = 0L;   // previous sum
      int retries = -1; // first iteration isn't retry
      try {
          for (;;) {
              if (retries++ == RETRIES_BEFORE_LOCK) {
                  for (int j = 0; j < segments.length; ++j)
                      ensureSegment(j).lock(); // force creation
              }
              sum = 0L;
              size = 0;
              overflow = false;
              for (int j = 0; j < segments.length; ++j) {
                  Segment<K,V> seg = segmentAt(segments, j);
                  if (seg != null) {
                      sum += seg.modCount;
                      int c = seg.count;
                      if (c < 0 || (size += c) < 0)
                          overflow = true;
                  }
              }
              if (sum == last)
                  break;
              last = sum;
          }
      } finally {
          if (retries > RETRIES_BEFORE_LOCK) {
              for (int j = 0; j < segments.length; ++j)
                  segmentAt(segments, j).unlock();
          }
      }
      return overflow ? Integer.MAX_VALUE : size;
  }