/**

     * The default concurrency level for this table, used when not

     * otherwise specified in a constructor.

     */

    static final int DEFAULT_CONCURRENCY_LEVEL = 16;       //默认的并发级别

/**
 * The maximum capacity, used if a higher value is implicitly
 * specified by either of the constructors with arguments.  MUST
 * be a power of two <= 1<<30 to ensure that entries are indexable
 * using ints.
 */
static final int MAXIMUM_CAPACITY = 1 << 30;        //最大容量

/**
 * The minimum capacity for per-segment tables.  Must be a power
 * of two, at least two to avoid immediate resizing on next use
 * after lazy construction.
 */
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;    //每个Segement中的桶的数量

/**
 * The maximum number of segments to allow; used to bound
 * constructor arguments. Must be power of two less than 1 << 24.
 */
static final int MAX_SEGMENTS = 1 << 16; // slightly conservative   //允许的最大的Segement的数量

/**
 * Mask value for indexing into segments. The upper bits of a
 * key's hash code are used to choose the segment.
 */
final int segmentMask;             //掩码，用来定位segements数组的位置

/**
 * Shift value for indexing within segments.
 */
final int segmentShift; 　　　　　　//偏移量，用来确认hash值的有效位

/**
 * The segments, each of which is a specialized hash table.
 */
final Segment<K,V>[] segments;    //相当于多个HashMap组成的数组

static final class Segment<K,V> extends ReentrantLock implements Serializable {  //内部类Segment,继承了ReentrantLock,有锁的功能

       /**

         * The maximum number of times to tryLock in a prescan before

         * possibly blocking on acquire in preparation for a locked

         * segment operation. On multiprocessors, using a bounded

         * number of retries maintains cache acquired while locating

         * nodes.

         */

        static final int MAX_SCAN_RETRIES =

            Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;

        /**

         * The per-segment table. Elements are accessed via

         * entryAt/setEntryAt providing volatile semantics.

         */

        transient volatile HashEntry<K,V>[] table;             //每个Segement内部都有一个table数组，相当于每个Segement都是一个HashMap

        transient int count;                            //这些参数与HashMap中的参数功能相同

        transient int modCount;

        transient int threshold;

        final float loadFactor;

        Segment(float lf, int threshold, HashEntry<K,V>[] tab) {

            this.loadFactor = lf;

            this.threshold = threshold;

            this.table = tab;

        }

        final V put(K key, int hash, V value, boolean onlyIfAbsent) {  //向Segement中添加一个元素

        }

@SuppressWarnings("unchecked")

    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;          　　　     //计算segement数组的大小，并且为2的倍数，默认情况下concurrentyLevel为16,那么ssize也为16

        while (ssize < concurrencyLevel) {

            ++sshift;               //ssize每次进行左移运算，因此sshift可以看做是ssize参数左移的位数

            ssize <<= 1;

        }
　　　　　

        this.segmentShift = 32 - sshift;   //segement偏移量

        this.segmentMask = ssize - 1;     //由于ssize为2的倍数，所以sengemnt为全1的，用来定位segement数组的下标

        if (initialCapacity > MAXIMUM_CAPACITY)

            initialCapacity = MAXIMUM_CAPACITY;
　　　　　　

        int c = initialCapacity / ssize;   //计算每个Segement中桶的数量

        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 =                        //初始化第一个segement

            new Segment<K,V>(loadFactor, (int)(cap * loadFactor),

                             (HashEntry<K,V>[])new HashEntry[cap]);

        Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];   //新建segements数组，并将s0赋值

        UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]

        this.segments = ss;

    }

@SuppressWarnings("unchecked")

    public V put(K key, V value) {

        Segment<K,V> s;

        if (value == null)        　　　　　　　　　　 //ConcurrentHashMap中value不能为空

            throw new NullPointerException();

        int hash = hash(key);                       //获取到key的hash值

        int j = (hash >>> segmentShift) & segmentMask;   //定位到某个segement位置

        if ((s = (Segment<K,V>)UNSAFE.getObject          //从上面的构造方法中我们知道，segments数组只有0位置的segment被初始化了，因此这里需要去检测计算出的位置的segment是否被初始化
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　由于是并发容器，所以使用UNSAFE中的方法

             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment

            s = ensureSegment(j);

        return s.put(key, hash, value, false);      //将元素插入到定位的Segement中

    }

final V put(K key, int hash, V value, boolean onlyIfAbsent) {   //segement中的put（）方法

            HashEntry<K,V> node = tryLock() ? null :   //获取锁，若获取不到锁，则县创建节点并返回

                scanAndLockForPut(key, hash, value);

            V oldValue;

            try {　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

                HashEntry<K,V>[] tab = table;          //之后的算法就与HashMap中相似了

                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;

        }

　　　　 int sshift = 0;　　　　　　　　

        int ssize = 1;          　　　     //计算segement数组的大小，并且为2的倍数，默认情况下concurrentyLevel为16,那么ssize也为16

        while (ssize < concurrencyLevel) {

            ++sshift;               //ssize每次进行左移运算，因此sshift可以看做是ssize参数左移的位数

            ssize <<= 1;

        }

　　　　　

        this.segmentShift = 32 - sshift;   //segement偏移量

        this.segmentMask = ssize - 1;     //由于ssize为2的倍数，所以sengemnt为全1的，用来定位segement数组的下标

 int j = (hash >>> segmentShift) & segmentMask;   //定位到某个segement位置