ConcurrentHashMap

HashTable和ConcurrHashMap分别是如何保证线程同步的？

HashTable

HashTable性能差主要是由于所有操作需要竞争同一把锁，而如果容器中有多把锁，每一把锁锁一段数据，这样在多线程访问时不同段的数据时，就不会存在锁竞争了，这样便可以有效地提高并发效率。这就是ConcurrentHashMap所采用的"分段锁"思想。

具体了解HashTable参见：https://www.imooc.com/article/details/id/23015

ConcurrentHashMap

Segment继承了ReentrantLock，所以它就是一种可重入锁（ReentrantLock)。在ConcurrentHashMap，一个Segment就是一个子哈希表，Segment里维护了一个HashEntry数组，并发环境下，对于不同Segment的数据进行操作是不用考虑锁竞争的。（就按默认的ConcurrentLeve为16来讲，理论上就允许16个线程并发执行）
所以，对于同一个Segment的操作才需考虑线程同步，不同的Segment则无需考虑。

对比一下JDK1.8中的ConcurrentHashMap

ConcurrentHashMap在1.8中的实现，相比于1.7的版本基本上全部都变掉了。首先，取消了Segment分段锁的数据结构，取而代之的是数组+链表（红黑树）的结构。

JDK1.8中彻底放弃了Segment转而采用的是Node，其设计思想也不再是JDK1.7中的分段锁思想。

Node：保存key，value及key的hash值的数据结构。其中value和next都用volatile修饰，保证并发的可见性。在JDK8中ConcurrentHashMap的结构，由于引入了红黑树，使得ConcurrentHashMap的实现非常复杂，我们都知道，红黑树是一种性能非常好的二叉查找树，其查找性能为O（logN），但是其实现过程也非常复杂，而且可读性也非常差,早期完全采用链表结构时Map的查找时间复杂度为O（N）。

什么时候扩容？
1 当前容量超过阈值
2 当链表中元素个数超过默认设定（8个），当数组的大小还未超过64的时候，此时进行数组的扩容，如果超过则将链表转化成红黑树

下面是1.8中的putVal()方法

final V putVal(K key, V value, boolean onlyIfAbsent) {
        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();
               // table[i]后面无节点时，直接创建Node（无锁操作）
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                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 {
                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;
                                }
                            }
                        }
                         //向红黑树中添加元素，TreeBin 结点的hash值为TREEBIN（-2）
                        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;
                            }
                        }
                    }
                }
                //binCount != 0 说明向链表或者红黑树中添加或修改一个节点成功
			    //binCount  == 0 说明 put 操作将一个新节点添加成为某个桶的首节点
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)//链表深度超过 8 转换为红黑树
                        treeifyBin(tab, i);
                         //oldVal != null 说明此次操作是修改操作
						 //直接返回旧值即可，无需做下面的扩容边界检查
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
         //CAS 式更新baseCount，并判断是否需要扩容
        addCount(1L, binCount);
        //程序走到这一步说明此次 put 操作是一个添加操作，否则早就 return 返回了
        return null;
    }

从上面代码可以看出，put的步骤大致如下：

1.参数校验。
2.若table[]未创建，则初始化。
3.当table[i]后面无节点时，直接创建Node（无锁操作）。
4.如果当前正在扩容，则帮助扩容并返回最新table[]。
5.然后在链表或者红黑树中追加节点。
6.最后还回去判断是否到达阀值，如到达变为红黑树结构。