在并发的情况下，通常使用ConcurrentHashMap来保证程序的效率

简介

ConcurrentHashMap原理是当一个线程占用锁访问其中一个段数据的时候，
其他段的数据也能被其他线程访问，
能够实现真正的并发访问。

据说曾经的
ConcurrentHashMap使用分段锁技术，segment锁，保护了多个hash桶
将数据分成一段一段的存储，
然后给每一段数据配一把锁。（老代码懒得去找了~~~~）

在JDK8里面变成了只对访问的hash桶加锁，一个锁只保护一个hash桶，细粒度更小，写操作的并发的到提升。

PUT方法

concurrentHashMap是通过casTabAt来保证值得可见性。

在不加锁的情况下，线程A使用casTabAt方法对map进行操作，线程B能够直接使用tabAt访问到map里面的值。

通过for循环+CAS操作，实现并发安全的方式就是无锁算法（lock free)的经典实现。

如果存在hash冲突，会对使用native方法tabAt读取出来的f加锁，对f进行转换成链表或者树的处理

/**
 * 这个变量初次初始化时候会被创建
 */
transient volatile Node<K,V>[] table;
/** 用于控制整个变量的操作，初始为0 */
private transient volatile int sizeCtl;
public V put(K key, V value) {
    return putVal(key, value, false);
}

/** 实现PUT方法 */
final V putVal(K key, V value, boolean onlyIfAbsent) {
    // Key不允许为空
    if (key == null || value == null) throw new NullPointerException();
    // 计算key的hash值防碰撞
    int hash = spread(key.hashCode());
    int binCount = 0;
    // 这边写一个死循环
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        // 如果表没有进行初始化则进行一个初始化
        if (tab == null || (n = tab.length) == 0)
            // 初始化
            tab = initTable();
            // 初始化之后进行下一轮循环
 
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 如果Map的最后i个元素为空,创建一个Node放到tab的第i个位置
            // 使用casTabAt进行塞值，如果塞失败会重新进行循环来处理
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            // 有一模一样的Hash值存在
            V oldVal = null;
            // 对存在冲突的那个对象加锁
            synchronized (f) {
                // 如果那个对象还没有转换成树
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            // 比较他们的当前锁住的对象f和传进来的hash值相同，Key相同或者对象地址相同
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                 // 相同值进行替换
                                oldVal = e.val;
                            if (!onlyIfAbsent)
                                e.val = value;
                                break;
                            }
                            // 否则以链表的形式跟在后面
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    // 成树操作
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }
            
            if (binCount != 0) {
                // 如果超过一个树的最大容量直接转换成树
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}
/** 初始化 */
private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        // sizeCtl小于0，说明已经有线程在对它进行处理，当前线程进行创建的时候则需要先等等
        if ((sc = sizeCtl) < 0)
            Thread.yield(); // lost initialization race; just spin
        // 使用底层代码保证只有一个值来改变sc的值   SIZECTL是当前类的内存地址，将状态修改成-1 
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    // DEFAULT_CAPACITY初始化为16
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    // 创建一个长度为n的数组
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    sc = n - (n >>> 2);
                }
            } finally {
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

GET方法

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    // 计算Hash
    int h = spread(key.hashCode());
    // 如果表不为空，且hash值存在
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        // key相同直接返回
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        // 如果上面连段逻辑都没有执行，使用链表的方式一段一段往下找    
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}