ConcurrentHashMap源码分析（一）

1.Hashtable
之前介绍过，Hashtable在put过程中加上了锁(synchronized)，我们都知道在我们的使用高并发的时候，第一个要点就是不能产生线程不安全的问题。我们现在存在Hashtable，并且还拥有锁的机制，那为什么还要有ConcurrentHashMap的存在呢？
我们先来分析一下Hashtable的缺点。

1. 所有锁的机制都存在阻塞问题，这个问题是不可避免的。
2. Hashtable在多个线程中，只允许一个线程访问put()，get()操作。效率可以说是非常的低，虽说安全可以保证但是单凭效率问题就被大部分人放弃了。

2.ConcurrentHashMap
ConcurrentHashMap将一个大的HashMap集合拆分成n多个不同的小的HashTable（Segment），默认的情况下是分成16个不同的
Segment。每个Segment中都有自己独立的HashEntry<K,V>[] table，并且ConcurrentHashMap的扩容，只针对于每个Segment进行扩容。
但是为什么我们会使用它呢？差距最大的就是在于ConcurrentHashMap的锁只针对于每个独立的Segment，只对Segment上锁，并且锁是乐观锁。

我们先看看jdk1.7的ConcurrentHashMap。
基于数组、HashEntry、Segment实现。利用到的锁：Lock锁、CAS锁、UNSAFE类，现在看看实现。
首先看构造函数。

里面有着三个参数。
DEFAULT_INITIAL_CAPACITY：static final int DEFAULT_INITIAL_CAPACITY = 16;默认数组长度
DEFAULT_LOAD_FACTOR：static final float DEFAULT_LOAD_FACTOR = 0.75f;默认加载因子
DEFAULT_CONCURRENCY_LEVEL：static final int DEFAULT_CONCURRENCY_LEVEL = 16;默认Segment的数目
再来到this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);方法

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;
  while (ssize < concurrencyLevel) {
      ++sshift;
      ssize <<= 1;
  }
  this.segmentShift = 32 - sshift;
  this.segmentMask = ssize - 1;
  if (initialCapacity > MAXIMUM_CAPACITY)
      initialCapacity = MAXIMUM_CAPACITY;
  int c = initialCapacity / ssize;
  if (c * ssize < initialCapacity)
      ++c;
  int cap = MIN_SEGMENT_TABLE_CAPACITY;
  while (cap < c)
      cap <<= 1;
  // create segments and segments[0]
  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];
  UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
  this.segments = ss;
}

1. if (concurrencyLevel > MAX_SEGMENTS)并发级别最高为2的16次方，不会再次变大
2. int sshift = 0;记录左移位的次数
3. int ssize = 1;记录segment数组的大小
4. this.segmentShift = 32 - sshift;用于计算index，右移的数据
5. this.segmentMask = ssize - 1;我们在hashmap见过，为什么使用数组大小-1，为了让数据更好的均匀分布。
6. int c = initialCapacity / ssize;用于之后初始化HashEntry[]的大小
7. int cap = MIN_SEGMENT_TABLE_CAPACITY;默认HashEntry[]的大小
8. Segment<K,V> s0 = new Segment<K,V>(loadFactor, (int)(cap * loadFactor), (HashEntry<K,V>[])new HashEntry[cap]);创建一个segment对象，通过默认构造函数初始化s0，并方便后期key落到其他的Segment时，好初始化HashEntry[]
9. Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize]; UNSAFE.putOrderedObject(ss, SBASE, s0);创建ss，并且将s0放入ss[0]
   目前构造函数已经结束了。我们再来看看put()方法

public V put(K key, V value) {
    Segment<K,V> s;
    if (value == null)
        throw new NullPointerException();
    int hash = hash(key);
    int j = (hash >>> segmentShift) & segmentMask;
    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);
}

1. int hash = hash(key);计算hash值
2. int j = (hash >>> segmentShift) & segmentMask;使用右移，将高位数据进行计算下标
3. Segment<K,V>)UNSAFE.getObject(segments, (j << SSHIFT) + SBASE)获取此下标是否存在Segment，没有则创建
4. s = ensureSegment(j);创建Segment
5. s.put(key, hash, value, false);进行put()方法

在前面的4、5中各有方法调用。先看看第4点的方法吧。
ensureSegment()方法：

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;
    if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
        Segment<K,V> proto = ss[0]; // use segment 0 as prototype
        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);
            while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                   == null) {
                if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
                    break;
            }
        }
    }
    return seg;
}

1. final Segment<K,V>[] ss = this.segments;获取当前的下标的Segment
2. (seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null获取默认的加载因子、参数信息、初始容量。在前面我们也提到过
3. (seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null再次判空，如果还为空，则创建Segment
4. (seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u) == null再次判空，并

使用while循环，也就是利用自旋CAS来创建对应Segment（CAS）
好了，现在就到了s.put(key, hash, value, false);方法。

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;
         HashEntry<K,V> first = entryAt(tab, index);
         for (HashEntry<K,V> e = first;;) {
             if (e != null) {
                 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 {
                 if (node != null)
                     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);
                 else
                     setEntryAt(tab, index, node);
                 ++modCount;
                 count = c;
                 oldValue = null;
                 break;
             }
         }
     } finally {
         unlock();
     }
     return oldValue;
 }

这里我们先看获取到锁吧。 tryLock() 在获取到锁会返回true，否则false。

1. HashEntry<K,V>[] tab = table;获取当前的全局table
2. int index = (tab.length - 1) & hash;获取下标
3. HashEntry<K,V> first = entryAt(tab, index);获取当前下标的HashEntry
4. if ((k = e.key) == key || (e.hash == hash && key.equals(k)))假如此key存在就直接替换key的value
5. node.setNext(first);将新数据插入到老数据之前，使用头插法
6. node = new HashEntry<K,V>(hash, key, value, first);当前下标下没有数据，这直接插入
7. unlock();释放锁

现在看看返回false的情况

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; // negative while locating node
      while (!tryLock()) {
          HashEntry<K,V> f; // to recheck first below
          if (retries < 0) {
              if (e == null) {
                  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) {
              e = first = f; // re-traverse if entry changed
              retries = -1;
          }
      }
      return node;
  }

这个方法是真的强悍。直接自旋，高大上

1. HashEntry<K,V> first = entryForHash(this, hash);获取当前时间的HashEntry，用于避免之后put数据出问题
2. int retries = -1;retries 初始值设为-1是为了遍历当前hash对应桶的链表，找到则停止遍历，未找到则会预创建一个节点；同时，如果头节点发生变化，则会重新进行遍历，直到自旋次数大于MAX_SCAN_RETRIES，使用lock加锁，获取锁失败则会进入等待队列
3. lock();retries 达到64就会停止自旋。
4. (f = entryForHash(this, hash)) != first判断目前的下标中的HashEntry是否发生了变化，如果发生了变化，就重新回到了自旋，之后进行回到之前的put()方法。