ConcurrentHashMap简单介绍

相比HashMap而言，是多线程安全的，其底层数据与HashMap的数据结构相同。

JDK1.7之前

通过对多个数组分段锁机制（Segment）来实现的加锁，默认16个Segment，16个分段，每个Segment对应Node[]数组，每个Segment有一把锁，也就是说对一个Segment里的Node[]数组的不同的元素如果要put操作的话，其实都是要竞争一个锁，串行化来处理的。

这种情况下，如果某一时间，同时并发访问同一个数组段，其最大并发度受段的个数限制，效率还是低。

JDK1.8后

实现原理摒弃了这种设计，做了锁粒度的细化，一个大的数组，数组里每个元素进行put操作，都是有一个不同的锁，刚开始进行put的时候，如果当前位置为空，执行CAS操作设值。

如果两个线程都是在数组[5]这个位置进行put，这个时候如果里面的值不为null，对数组[5]这个位置进行put的时候，采取的是synchronized(f)加锁，锁住这个节点，只让一个线程来处理链表或红黑树。

final V putVal(K key, V value, boolean onlyIfAbsent) {

    if (key == null || value == null) throw new NullPointerException();

    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) {//如果当前位置没有值，就进入CAS操作，成功就结束

            if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null)))//多线程的时候不成功，进入下次for循环设值

                break;                   // no lock when adding to empty bin

        }

        else if ((fh = f.hash) == MOVED)

            tab = helpTransfer(tab, f);

        else {

            V oldVal = null;

            synchronized (f) {//锁住这个节点，只让一个线程来处理链表或红黑树

                if (tabAt(tab, i) == f) {

                    if (fh >= 0) {

                        binCount = 1;

                        for (Node<K,V> e = f;; ++binCount) {

                            K ek;

                            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;

如何保证取值的安全？

如果是get(key)的时候，是基于Unsafe.getObjectVolatile()，volatile读机制，来读取数组里的节点，而节点里面的value也是加了volatile，尽可能给你保证说是读到了其他线程修改的一个最新的值，但是不需要加锁volatile V val;

Volatile底部实现原理，关注我，后面会讲解。

ConcurrentHashMap和Hashtable的区别

主要体现在实现线程安全的方式上不同。

1、HashTable内部的方法基本都经过 synchronized 修饰。而synchronized关键字加锁是对整个对象进行加锁，也就是说在进行put等修改Hash表的操作时，锁住了整个Hash表，从而使得其表现的效率低下。

2、ConcurrentHashMap主要从之前的分段加锁机制优化到现在的锁粒度的细化。

下篇开始讲解List集合相关特性及原理。