​让我们来看看，多线程下的Map是如何实现线程安全的

//散列映射表的默认初始容量为 16。
 static final int DEFAULT_INITIAL_CAPACITY = 16;
 
 //散列映射表的默认装载因子为 0.75，用于表示segment中包含的HashEntry元素的个数与HashEntry[]数组长度的比值。当某个segment中包含的HashEntry元素的个数超过了HashEntry[]数组的长度与装载因子的乘积时，将触发扩容操作。
 static final float DEFAULT_LOAD_FACTOR = 0.75f;
 
 //散列表的默认并发级别为 16。该值表示segment[]数组的长度，也就是锁的总数。可以在构造函数中更改
 static final int DEFAULT_CONCURRENCY_LEVEL = 16;
 
 //散列表的最大容量
 static final int MAXIMUM_CAPACITY = 1 << 30;
 
 //segment中HashEntry[]数组最小长度
 static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
 
 //散列表的最大段数，也就是segment[]数组的最大长度
 static final int MAX_SEGMENTS = 1 << 16; // slightly conservative
 
 //在执行size()和containsValue(value)操作时,ConcurrentHashMap的做法是先尝试 RETRIES_BEFORE_LOCK 次( 即，2次 )通过不锁住segment的方式来统计、查询各个segment，如果2次执行过程中，容器的modCount发生了变化，则再采用加锁的方式来操作所有的segment
 static final int RETRIES_BEFORE_LOCK = 2;
 
 //segmentMask用于定位segment在segment[]数组中的位置。segmentMask是与运算的掩码，等于segment[]数组size减1，掩码的二进制各个位的值都是1( 因为，数组长度总是2^N )。
 final int segmentMask;
 
 //segmentShift用于决定H(key)参与segmentMask与运算的位数(高位)，这里指在从segment[]数组定位segment：通过key的哈希结果的高位与segmentMask进行与运算哈希的结果。(详见下面举例)
 final int segmentShift;
 
 //Segment 类继承于 ReentrantLock 类，从而使得 Segment 对象能充当锁的角色。
 final ConcurrentHashMap.Segment<K, V>[] segments;

/*****************put方法****************/
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;
      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;
}
/************scanAndLockForPut方法**************/
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;
}

transient volatile Node<K,V>[] table;

public V put(K key, V value) {
    //简简单单一个跳转
    return putVal(key, value, false);
}

/** Implementation for put and putIfAbsent */
//真正的put操作
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;
for (Node<K,V>[] tab = table;;) {
    Node<K,V> f; int n, i, fh;
    // 如果table为空，初始化；否则，根据hash值计算得到数组索引i，如果tab[i]为空，直接新建节点Node即可。注：tab[i]实质为链表或者红黑树的首节点。
    if (tab == null || (n = tab.length) == 0)
        tab = initTable();
    else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
        if (casTabAt(tab, i, null,
                     new Node<K,V>(hash, key, value, null)))
            break;                   
    }
    // 如果tab[i]不为空并且hash值为MOVED，说明该链表正在进行transfer操作，返回扩容完成后的table。
    else if ((fh = f.hash) == MOVED)
        tab = helpTransfer(tab, f);
    else {
        V oldVal = null;
        // 针对首个节点进行加锁操作，而不是segment，进一步减少线程冲突
        synchronized (f) {
            if (tabAt(tab, i) == f) {
                if (fh >= 0) {
                    binCount = 1;
                    for (Node<K,V> e = f;; ++binCount) {
                        K ek;
                        // 如果在链表中找到值为key的节点e，直接设置e.val = value即可。
                        if (e.hash == hash &&
                            ((ek = e.key) == key ||
                             (ek != null && key.equals(ek)))) {
                            oldVal = e.val;
                            if (!onlyIfAbsent)
                                e.val = value;
                            break;
                        }
                        // 如果没有找到值为key的节点，直接新建Node并加入链表即可。
                        Node<K,V> pred = e;
                        if ((e = e.next) == null) {
                            pred.next = new Node<K,V>(hash, key,
                                                      value, null);
                            break;
                        }
                    }
                }
                // 如果首节点为TreeBin类型，说明为红黑树结构，执行putTreeVal操作。
                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;
                    }
                }
            }
        }
        if (binCount != 0) {
            // 如果节点数>＝8，那么转换链表结构为红黑树结构。
            if (binCount >= TREEIFY_THRESHOLD)
                treeifyBin(tab, i);
            if (oldVal != null)
                return oldVal;
            break;
        }
    }
}
// 计数增加1，有可能触发transfer操作(扩容)。
addCount(1L, binCount);
return null;
}