/**
     * 这里表示由多个segment组成
     */
    final Segment<K,V>[] segments;

//继承自ReentrantLock，关于ReentrantLock后面细聊
    static final class Segment<K,V> extends ReentrantLock implements Serializable {

/**
 * 创建一个具有指定初始容量、负载因子和并发级别的新的空 ConcurrentHashMap。
 *
 * @param initialCapacity 初始容量。实现会进行内部调整以容纳这么多元素。
 * 用initialCapacity除以ssize就是每个segment的初始大小（会始终保证是2的幂次）
 * @param loadFactor 负载因子阈值，用于控制何时进行调整。当每个桶的平均元素数超过此阈值时，可能会进行调整。
 * 要注意的是segment的个数是不能扩容的，但是每个segment的内部可以扩展
 * @param concurrencyLevel 预估的并发更新线程数。实现会进行内部调整以尽量容纳这么多线程。
 * 这个值就是segment的数量，简单理解就是控制了并发度，该值在初始化之后就不能更改了
 * 默认的segment值是16（会始终保证是2的幂次）
 * @throws IllegalArgumentException 如果初始容量为负数或负载因子或并发级别为非正值。
 */
@SuppressWarnings("unchecked")
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
    // 检查负载因子是否大于0，初始容量是否为非负值，并发级别是否为正值
    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;  // 等效于 ssize = ssize * 2;
    }

    // 设置段的移位值和掩码
    this.segmentShift = 32 - sshift;
    this.segmentMask = ssize - 1;

    // 如果初始容量超过最大容量，则设置为最大容量
    if (initialCapacity > MAXIMUM_CAPACITY) {
        initialCapacity = MAXIMUM_CAPACITY;
    }

    // 计算每段的初始容量
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity) {
        ++c;  // 调整容量以确保能够容纳所有元素
    }

    // 找到大于等于c的最小2的幂值
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    while (cap < c) {
        cap <<= 1;  // 等效于 cap = cap * 2;
    }

    // 创建段和段表的第一个段
    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);  // 有序写入段表的第一个段
    this.segments = ss;
}

/**
 * 将指定的键映射到此表中的指定值。键和值均不能为 null。
 *
 * <p> 可以通过调用带有与原始键相等的键的 <tt>get</tt> 方法来检索该值。
 *
 * @param key 与指定值关联的键
 * @param value 与指定键关联的值
 * @return 与 <tt>key</tt> 关联的先前值，如果没有针对 <tt>key</tt> 的映射，则返回 <tt>null</tt>
 * @throws NullPointerException 如果指定的键或值为 null
 */
@SuppressWarnings("unchecked")
public V put(K key, V value) {
    Segment<K, V> s;
    // 检查值是否为 null，如果是，则抛出 NullPointerException
    if (value == null) {
        throw new NullPointerException();
    }

    // 计算键的哈希值
    int hash = hash(key);

    // 根据哈希值计算段索引
    int j = (hash >>> segmentShift) & segmentMask;

    // 尝试获取指定段。如果段为空，则调用 ensureSegment 创建段
    if ((s = (Segment<K, V>) UNSAFE.getObject
         (segments, (j << SSHIFT) + SBASE)) == null) {
        s = ensureSegment(j);
    }

    // 调用段的 put 方法，将键值对插入段中，并返回先前与键关联的值
    return s.put(key, hash, value, false);
}

/**
 * 返回给定索引的段，如果不存在则创建它并通过 CAS 操作记录到段表中。
 *
 * @param k 段的索引
 * @return 对应索引的段
 */
@SuppressWarnings("unchecked")
private Segment<K, V> ensureSegment(int k) {
    final Segment<K, V>[] ss = this.segments;  // 获取当前的段表
    long u = (k << SSHIFT) + SBASE;  // 计算段在段表中的原始偏移量
    Segment<K, V> seg;

    // 尝试获取段，使用 volatile 读取确保可见性
    if ((seg = (Segment<K, V>) UNSAFE.getObjectVolatile(ss, u)) == null) {
        Segment<K, V> proto = 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) {
            Segment<K, V> s = new Segment<K, V>(lf, threshold, tab);  // 创建新的段
            while ((seg = (Segment<K, V>) UNSAFE.getObjectVolatile(ss, u)) == null) {
                // 使用 CAS 操作将新的段设置到段表中
                if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s)) {
                    break;  // 成功设置段后退出循环
                }
            }
        }
    }
    return seg;  // 返回段
}

/**
 * 将指定的键映射到此表中的指定值。键和值均不能为 null。
 *
 * @param key 键，与指定值关联
 * @param hash 键的哈希值
 * @param value 值，与指定键关联
 * @param onlyIfAbsent 如果为 true，则仅当键尚未关联值时才插入
 * @return 与键关联的先前值，如果没有，则返回 null
 */
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;  // 返回先前的值
}

/**
 * 在尝试获取锁的过程中扫描包含给定键的节点，如果未找到则创建并返回一个新节点。
 * 返回时，确保锁已被持有。与大多数方法不同，此方法中的 equals 调用未被筛选：
 * 由于遍历速度无关紧要，因此我们可以通过此方法来预热相关代码和访问。
 *
 * @param key 键
 * @param hash 键的哈希值
 * @param value 值
 * @return 如果未找到键则返回一个新节点，否则返回 null
 */
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; // 在定位节点时为负数

    // 尝试获取锁
    while (!tryLock()) {
        HashEntry<K, V> f; // 用于重新检查下面的第一个条目
        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;
        }
        // 如果重试次数为偶数且第一个条目已改变
        else if ((retries & 1) == 0 && (f = entryForHash(this, hash)) != first) {
            e = first = f; // 如果条目已改变，则重新遍历
            retries = -1;
        }
    }
    return node; // 返回新创建的节点（如果有）
}

/**
 * 根据哈希值获取对应的第一个条目。
 *
 * @param segment 当前段
 * @param hash 键的哈希值
 * @return 对应的第一个条目
 */
private HashEntry<K, V> entryForHash(Segment<K, V> segment, int hash) {
    HashEntry<K, V>[] tab = segment.table;
    return tab[(tab.length - 1) & hash];
}