jdk-ConcurrentHashMap(一)

今天参与了一个java的招聘，本人自己的能力其实也一般，但是不巧的是，今天那位同学水平也非常一般，很多问题自己都没去研究过，在问过他平时遇到过什么问题时，这个问题其实很一般，很一般，稍微用点心的，其实都能记住自己遇到的一些麻烦事吧，挑几个来说下就行，或者自己私下准备几个自己能理解的问题，但是他直接回答没什么问题。。。。平时就是一些增删改查啊，没什么很难的问题，说到此，我大概明白了他的日常工作了，基于需求，在SSM框架内增删改查，简单来说，就是我之前看到过一篇文章里总结的SSM型程序员，这种程序员值8K。(这个观点不是我的，是那篇文章的)。
但是他开价竟然是12K，这就没法接受了，现在功能型程序员也能有这么多钱么？这里我指的是只追求于用框架进行增删改查的程序员，而不想去研究其理，虽然不是每个程序员都能做技术型项目，但是也需要去研究你当前框架啊，也需要去研究你所使用的语言啊，但是上面这位一点没有，问过几个简单的java知识，茫茫然知道些东西，但是并不知道原理，因此在回答时总是抓不着要害进行回答，其实很多问题，只要你抓住要害，回答出本质，一般就没什么为难的。
废话有点多，知识感慨一下，希望自己不要变成这个样子，做个有追求的人吧。
今天研究一下ConcurrentHashMap。
底层图如下，熟悉这些集合必须先熟悉它们的底层结构，在结构上再去结合代码分析，事半功倍。

public ConcurrentHashMap(int initialCapacity,
                                float loadFactor, int concurrencyLevel) {
            //initialCapacity和concurrencyLevel默认都是16，我们都先以默认值分析,loadFactor加载因子 0.75f，这些值和hashmap差不多
            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其实是2的指数，ssize是大小
                //1.假设都是传入0.75f,16.那么ssize是2^4=16,sshift是4
                //2.假设传入的是0.75f,7.那么ssize是2^3=8,sshift是3.ssize是不小于concurrencyLevel的最小2次方的数
                ++sshift;
                ssize <<= 1;  // a. 1 * 2^1 = 2   b. 2 * 2^1 = 4  c. 4 * 2^1 = 8
                //ssize是最终segment的大小
            }
            this.segmentShift = 32 - sshift; //segmentShift 为 32-n对于这个为什么是32，暂时不清楚，或许是下面移位的要求
            this.segmentMask = ssize - 1; //segmentMask put时做与运算，表明当前数据在哪个segment中.segmentMask 为 2^n-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[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;
        }

public V put(K key, V value) {
        Segment<K,V> s;
        if (value == null)
            //值不能为null
            throw new NullPointerException();
        int hash = hash(key);  //这边key也不能为null，不然做hash值会有NPE问题，不同于hashMap，在key为null时会有一个putNull操作。
        //这边segmentShift 为32-4=28，将hash后的值无符号右移28位
        //0000 0000 0000 0000 0000 0000 0000 xxxx,也就是决定落在哪个segment中是由hash值的高4位决定的
        //segmentMask 在这边为 2^4 - 1 = 15
        int j = (hash >>> segmentShift) & segmentMask;
        if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
                (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
            //如果hash值处是null的话，初始化一个Segment
            s = ensureSegment(j);
        return s.put(key, hash, value, false);
    }

    //ensureSegment没什么好说的，底部采用CAS在hash值出去初始化一个Segment，
    //使用ss[0]处的作为模型创建出来
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;
    }

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
        //tryLock使用的是ReentrantLock，获取成功返回true，那么node就是null,获取失败，进入scanAndLockForPut流程
        HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);   //node值要么是null，要么是新node
        V oldValue;
        try {
            HashEntry<K,V>[] tab = table;
            int index = (tab.length - 1) & hash;   //此处和hashmap一致,获取这个key的hash值在table中的位置
            HashEntry<K,V> first = entryAt(tab, index); //获取table中index位置的第一个元素,这个地方和上面scanAndLockForPut里类似
            for (HashEntry<K,V> e = first;;) {
                if (e != null) {
                    //e不为null时，循环遍历比较，和hashmap类似，获取old值，用于返回
                    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不为null,说明scanAndLockForPut中新建了node，原本此处是null值，所以新建出来一个node,将node的next赋值为first，也就是null
                        node.setNext(first);
                    else
                        //node为null，说明要么是获取锁成功直接进入的，那么也是设置next为first，要么就是scanAndLockForPut返回null,说明此处原本有值。
                        //那么原本有值为什么HashEntry<K,V> first = entryAt(tab, index);为什么first是null呢？也是由于多线程的关系，可以试想一下，不难
                        node = new HashEntry<K,V>(hash, key, value, first);
                    int c = count + 1;
                    if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                        //超过阈值，rehash，暂时不care
                        rehash(node);
                    else
                        setEntryAt(tab, index, node); //此处将此node置于index处的第一个位置上，(不确定???)
                    ++modCount;
                    count = c;
                    oldValue = null;  //此处就能证明原本的值其实为null.在这个else逻辑段内的返回值是null
                    break;
                }
            }
        } finally {
            unlock();
        }
        return oldValue;
    }

//tryLock失败时进入，说明此时已有线程获取到Segment处的锁了。
    //根据下面的分析，总的来说，这个方法就是在获取锁失败时来确保当前线程是否需要新增node
    //注意到这个方法，只要hash处不是null，那么就返回的null，如果是null，那么返回的是新node
    private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
        HashEntry<K,V> first = entryForHash(this, hash); //获取这个Segment中对应hash值处的第一个enrty
        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) {
                //retries为-1,即首次尝试,如果hash值处的entery为null,则新建一个entry node
                if (e == null) {
                    if (node == null) // speculatively create node
                        node = new HashEntry<K,V>(hash, key, value, null);
                    retries = 0;
                }
                //一直后移,key相等时,尝试次数为0,说明不需要新建node了
                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) {
                //确保之前读取的该位置的值没有改变。
                //有两张情况.
                //     1.线程1进入时 原本此处为null,因此该线程在上面新建过一个node，此处判断时，线程2又改变了此处的值
                //     1.1假设线程1再次tryLock时，成功了，那么线程1直接返回了刚刚创建的node,下面肯定会进入修改的逻辑，没毛病.假设线程2修改为<key,2>,那么线程1修改的值为<key,1>.
                //     1.2假设线程2再次tryLock时，还是失败,那么此时线程1进入的是key判断流程，发现key是相等的,也是没毛病，等待获取锁
                //     2.线程1进入时，此处是有node的，这种情况读者自己分析吧,原理一样的
                e = first = f; // re-traverse if entry changed
                retries = -1;
            }
        }
        return node;
    }

public V get(Object key) {
        Segment<K,V> s; // manually integrate access methods to reduce overhead
        HashEntry<K,V>[] tab;
        int h = hash(key);
        long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
        //依然做了两次hash定位，找到该查找元素的位置，然后去做循环，返回值
        if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
                (tab = s.table) != null) {
            for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                    (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
                 e != null; e = e.next) {
                K k;
                if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                    return e.value;
            }
        }
        return null;
    }

public V remove(Object key) {
        int hash = hash(key);
        //先将key做一次hash，定位Segment
        Segment<K,V> s = segmentForHash(hash);
        //取出当前所在的Segment，可以看见，在ConcurrentMap中，读取时不需要加锁
        return s == null ? null : s.remove(key, hash, null);
    }

final V remove(Object key, int hash, Object value) { //注意这边value传入的是null
        if (!tryLock())   //尝试获取锁，成功返回true，失败返回false
            scanAndLock(key, hash); //获取锁失败之后进入scanandlock流程，这个流程其实就是在做扫描的工作，直至获取到锁，执行下面的逻辑
        V oldValue = null;
        try {
            HashEntry<K,V>[] tab = table;
            int index = (tab.length - 1) & hash;
            HashEntry<K,V> e = entryAt(tab, index);  //取出table中的index处的第一个值
            HashEntry<K,V> pred = null; //前驱节点
            while (e != null) {
                K k;
                HashEntry<K,V> next = e.next;
                if ((k = e.key) == key ||
                    (e.hash == hash && key.equals(k))) {  //此处刚好第一个节点就是需要删除的
                    V v = e.value;
                    if (value == null || value == v || value.equals(v)) {
                        if (pred == null)                 //如果此时prev是null，说明没有后移过,再次保证首节点是需删除节点
                            setEntryAt(tab, index, next);  //设置index处的值为next节点
                        else
                            pred.setNext(next);   // pred不是null，说明此时e指向的next节点是需要删除的,直接将pred指向next,也就是e.next.next节点。注意此时e指向next
                        ++modCount;
                        --count;
                        oldValue = v;
                    }
                    break;
                }
                pred = e;       //当前节点不是需删除节点, prev指向当前
                e = next;       // 当前节点后移
            }
        } finally {
            unlock();
        }
        return oldValue;  //最终return旧值
    }
	//正如注释所说，类似上面的scan操作，但是简单许多
	//首先我们发现这个方法并没有返回值，那这个方法的意义何在呢？
	//我们可以看见tryLock那个方法
	//假设外层的tryLock没有获取到锁，
	//1.那么进入这个方法之后立马获取到了，那么此时这个锁仍然锁在了当前Segment上了
	//2.进入方法后第一次没有获取到锁,那么之后不管执行1,2,3,4哪一个逻辑，最终这个锁仍然是加在当前Segment上。
	//那么可以猜想这个方法其实是保证外层没有获取到锁的线程，在这个方法内不断轮询，但是仍保证锁是加在当前Segment上
	private void scanAndLock(Object key, int hash) {
        // similar to but simpler than scanAndLockForPut
        HashEntry<K,V> first = entryForHash(this, hash);    //获取table中hash值处的第一个entry。
        HashEntry<K,V> e = first;  
        int retries = -1;
        while (!tryLock()) {   //这边依然是轮询
            HashEntry<K,V> f;
            if (retries < 0) {
                if (e == null || key.equals(e.key))
                    retries = 0;   //1
                else
                    e = e.next;    //2
            }
            else if (++retries > MAX_SCAN_RETRIES) {
                lock();   //3
                break;
            }
            else if ((retries & 1) == 0 &&
                     (f = entryForHash(this, hash)) != first) {
                e = first = f;   //4
                retries = -1;
            }
        }
    }

基于上面分析，画个图吧，假设现在map中存储的数据如下：需要删除的数据为entry2.

第一次进入时e指向entry1，next指向entry2

第一次没有找到需要删除的entry2，进入第二次循环。

第二次找到了，因此将pred指向的entry1的next指向e.next。也就是entry3，对于concurrentHashMap的内部图删除分析不难。

那么，万一在读取时刚刚好删除了咋办呢？不要紧，可以去看看Segment和Entry内部变量的类型定义，都是volatile的，基于happen-before原则，读都是在写之后的，可以保证读取的都是最新的数据。