static final class HashEntry<K,V> {       final K key;                       // 声明 key 为 final 型       final int hash;                   // 声明 hash 值为 final 型       volatile V value;                 // 声明 value 为 volatile 型       final HashEntry<K,V> next;      // 声明 next 为 final 型        HashEntry(K key, int hash, HashEntry<K,V> next, V value) {           this.key = key;           this.hash = hash;           this.next = next;           this.value = value;       }}

static final class Segment<K,V> extends ReentrantLock implements Serializable {       /**        * 在本 segment 范围内，包含的 HashEntry 元素的个数        * 该变量被声明为 volatile 型        */       transient volatile int count;        /**        * table 被更新的次数        */       transient int modCount;        /**        * 当 table 中包含的 HashEntry 元素的个数超过本变量值时，触发 table 的再散列        */       transient int threshold;        /**        * table 是由 HashEntry 对象组成的数组        * 如果散列时发生碰撞，碰撞的 HashEntry 对象就以链表的形式链接成一个链表        * table 数组的数组成员代表散列映射表的一个桶        * 每个 table 守护整个 ConcurrentHashMap 包含桶总数的一部分        * 如果并发级别为 16，table 则守护 ConcurrentHashMap 包含的桶总数的 1/16        */       transient volatile HashEntry<K,V>[] table;        /**        * 装载因子        */       final float loadFactor;        Segment(int initialCapacity, float lf) {           loadFactor = lf;           setTable(HashEntry.<K,V>newArray(initialCapacity));       }        /**        * 设置 table 引用到这个新生成的 HashEntry 数组        * 只能在持有锁或构造函数中调用本方法        */       void setTable(HashEntry<K,V>[] newTable) {           // 计算临界阀值为新数组的长度与装载因子的乘积           threshold = (int)(newTable.length * loadFactor);           table = newTable;       }        /**        * 根据 key 的散列值，找到 table 中对应的那个桶（table 数组的某个数组成员）        */       HashEntry<K,V> getFirst(int hash) {           HashEntry<K,V>[] tab = table;           // 把散列值与 table 数组长度减 1 的值相“与”，// 得到散列值对应的 table 数组的下标           // 然后返回 table 数组中此下标对应的 HashEntry 元素           return tab[hash & (tab.length - 1)];       }}

public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>       implements ConcurrentMap<K, V>, Serializable {    /**    * 散列映射表的默认初始容量为 16，即初始默认为 16 个桶    * 在构造函数中没有指定这个参数时，使用本参数    */   static final     int DEFAULT_INITIAL_CAPACITY= 16;    /**    * 散列映射表的默认装载因子为 0.75，该值是 table 中包含的 HashEntry 元素的个数与* table 数组长度的比值    * 当 table 中包含的 HashEntry 元素的个数超过了 table 数组的长度与装载因子的乘积时，* 将触发 再散列    * 在构造函数中没有指定这个参数时，使用本参数    */   static final float DEFAULT_LOAD_FACTOR= 0.75f;    /**    * 散列表的默认并发级别为 16。该值表示当前更新线程的估计数    * 在构造函数中没有指定这个参数时，使用本参数    */   static final int DEFAULT_CONCURRENCY_LEVEL= 16;    /**    * segments 的掩码值    * key 的散列码的高位用来选择具体的 segment    */   final int segmentMask;    /**    * 偏移量    */   final int segmentShift;    /**    * 由 Segment 对象组成的数组    */   final Segment<K,V>[] segments;    /**    * 创建一个带有指定初始容量、加载因子和并发级别的新的空映射。    */   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;        // 寻找最佳匹配参数（不小于给定参数的最接近的 2 次幂）       int sshift = 0;       int ssize = 1;       while(ssize < concurrencyLevel) {           ++sshift;           ssize <<= 1;       }       segmentShift = 32 - sshift;       // 偏移量值       segmentMask = ssize - 1;           // 掩码值       this.segments = Segment.newArray(ssize);   // 创建数组        if (initialCapacity > MAXIMUM_CAPACITY)           initialCapacity = MAXIMUM_CAPACITY;       int c = initialCapacity / ssize;       if(c * ssize < initialCapacity)           ++c;       int cap = 1;       while(cap < c)           cap <<= 1;        // 依次遍历每个数组元素       for(int i = 0; i < this.segments.length; ++i)           // 初始化每个数组元素引用的 Segment 对象this.segments[i] = new Segment<K,V>(cap, loadFactor);   }    /**    * 创建一个带有默认初始容量 (16)、默认加载因子 (0.75) 和 默认并发级别 (16) * 的空散列映射表。    */   public ConcurrentHashMap() {       // 使用三个默认参数，调用上面重载的构造函数来创建空散列映射表this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);}}

清单 4.Put 方法的实现
public V put(K key, V value) {       if (value == null)          //ConcurrentHashMap 中不允许用 null 作为映射值           throw new NullPointerException();       int hash = hash(key.hashCode());        // 计算键对应的散列码       // 根据散列码找到对应的 Segment       return segmentFor(hash).put(key, hash, value, false);}然后，根据 hash 值找到对应的Segment 对象：清单 5.根据 hash 值找到对应的 Segment
/**    * 使用 key 的散列码来得到 segments 数组中对应的 Segment    */final Segment<K,V> segmentFor(int hash) {   // 将散列值右移 segmentShift 个位，并在高位填充 0   // 然后把得到的值与 segmentMask 相“与”// 从而得到 hash 值对应的 segments 数组的下标值// 最后根据下标值返回散列码对应的 Segment 对象       return segments[(hash >>> segmentShift) & segmentMask];}最后，在这个 Segment 中执行具体的 put 操作：清单 6.在 Segment 中执行具体的 put 操作
V put(K key, int hash, V value, boolean onlyIfAbsent) {           lock();  // 加锁，这里是锁定某个 Segment 对象而非整个 ConcurrentHashMap           try {               int c = count;                if (c++ > threshold)     // 如果超过再散列的阈值                   rehash();              // 执行再散列，table 数组的长度将扩充一倍                HashEntry<K,V>[] tab = table;               // 把散列码值与 table 数组的长度减 1 的值相“与”               // 得到该散列码对应的 table 数组的下标值               int index = hash & (tab.length - 1);               // 找到散列码对应的具体的那个桶               HashEntry<K,V> first = tab[index];                HashEntry<K,V> e = first;               while (e != null && (e.hash != hash || !key.equals(e.key)))                   e = e.next;                V oldValue;               if (e != null) {            // 如果键 / 值对以经存在                   oldValue = e.value;                   if (!onlyIfAbsent)                       e.value = value;    // 设置 value 值               }               else {                        // 键 / 值对不存在                   oldValue = null;                   ++modCount;         // 要添加新节点到链表中，所以 modCont 要加 1                    // 创建新节点，并添加到链表的头部                   tab[index] = new HashEntry<K,V>(key, hash, first, value);                   count = c;               // 写 count 变量               }               return oldValue;           } finally {               unlock();                     // 解锁           }       }

V remove(Object key, int hash, Object value) {           lock();         // 加锁           try{               int c = count - 1;               HashEntry<K,V>[] tab = table;               // 根据散列码找到 table 的下标值               int index = hash & (tab.length - 1);               // 找到散列码对应的那个桶               HashEntry<K,V> first = tab[index];               HashEntry<K,V> e = first;               while(e != null&& (e.hash != hash || !key.equals(e.key)))                   e = e.next;                V oldValue = null;               if(e != null) {                   V v = e.value;                   if(value == null|| value.equals(v)) { // 找到要删除的节点                       oldValue = v;                       ++modCount;                       // 所有处于待删除节点之后的节点原样保留在链表中                       // 所有处于待删除节点之前的节点被克隆到新链表中                       HashEntry<K,V> newFirst = e.next;// 待删节点的后继结点                       for(HashEntry<K,V> p = first; p != e; p = p.next)                           newFirst = new HashEntry<K,V>(p.key, p.hash,                                                         newFirst, p.value);                       // 把桶链接到新的头结点                       // 新的头结点是原链表中，删除节点之前的那个节点                       tab[index] = newFirst;                       count = c;      // 写 count 变量                   }               }               return oldValue;           } finally{               unlock();               // 解锁           }       }

transient volatile int count;

V get(Object key, int hash) {           if(count != 0) {       // 首先读 count 变量               HashEntry<K,V> e = getFirst(hash);               while(e != null) {                   if(e.hash == hash && key.equals(e.key)) {                       V v = e.value;                       if(v != null)                                      return v;                       // 如果读到 value 域为 null，说明发生了重排序，加锁后重新读取                       return readValueUnderLock(e);                   }                   e = e.next;               }           }           return null;       }