ConcurrentHashMap原理基于JDK1.7源码

多线程高并发情况下，hashmap会出现问题。

hashtable也可以保证线程安全问题

建议使用

ConcurrentHashMap！！！！

key在计算的时候 是计算两次，第一次计算在哪个segment，第二次是在寻找数组下标

segment基本原理

工作原理：中途多了一个寻找segment的过程，当两个线程同时进行时，如果计算的segement一样，其中一个segment.lock(),下一个就会等待上一个线程释放。

源码

初始化

initialCapacity==16   Segment[16]

loadFactor==0.75f    HashEntry<K,V>[] 0.75

concurrencyLevel==16   分成16个Segment对象

MIN_Segment_TABLE_CAPACITY=2  
是单独一个Segment中数组容量是2

MAX_SEGMENTS=2<<16  最大的并发级别是2的16次幂

*通过构造函数，初始化了一个Segment[0]的对象，原因是如果有一个元素下标为Segment[4]的对象，那么他会复制一个Segment[0]的对象模板

public ConcurrentHashMap(int initialCapacity,//这里以默认的无参构造器参数为例，initialCapacity==16，loadFactor==0.75f，concurrencyLevel==16    concurrencyLevel指的是并发级别
                             float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();//1)检查各参数是否符合要求
        if (concurrencyLevel > MAX_SEGMENTS)
            concurrencyLevel = MAX_SEGMENTS;
        // Find power-of-two sizes best matching arguments
        int sshift = 0;
        int ssize = 1;
        while (ssize < concurrencyLevel) {//2)根据concurrencyLevel=16,计算Segment[]的容量ssize=16与扩容移位条件sshift=4
            ++sshift;
            ssize <<= 1;
        }
        this.segmentShift = 32 - sshift;//3)根据sshift与ssize计算将来用于定位到相应Segment的参数segmentShift与segmentMask
        this.segmentMask = ssize - 1;//4)根据ssize创建Segment[]数组，容量为ssize(16)
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        int c = initialCapacity / ssize;//5)根据initialCapacity(16)与ssize计算用于计算HashEntry[]容量的参数c(1)
        if (c * ssize < initialCapacity)//6)根据c计算HashEntry[]的容量cap(1)
            ++c;// 为了少执行这一句，最好将initialCapacity设置为2的几次方
        int cap = MIN_SEGMENT_TABLE_CAPACITY;//7)根据cap与loadFactor(0.75)为每一个Segment[i]都实例化一个Segment
        while (cap < c)
            cap <<= 1;// 创建容量
        // create segments and segments[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;
    }

put元素
1.7中put元素是用头插法
使用Lock锁，
UNSAFE查询最新数据
使用 CAS做修改

@SuppressWarnings("unchecked")
    public V put(K key, V value) {
        Segment<K,V> s;
        if (value == null)
            throw new NullPointerException();
            计算key的值，用来找到Segment
        int hash = hash(key);
        int j = (hash >>> segmentShift) & segmentMask;
        if ((s = (Segment<K,V>)UNSAFE.getObject          
             (segments, (j << SSHIFT) + SBASE)) == null) 
            s = ensureSegment(j);
        return s.put(key, hash, value, false);
    }

扩容
扩容是segment是单独一个segment对象一个里边的扩容

@SuppressWarnings("unchecked")
    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;
    }

参考文章：

https://blog.51cto.com/u_14220760/2364724

https://www.cnblogs.com/rain4j/p/10972090.html