ConcurrentHashMap

图解ConcurrentHashmap结构

java1.7版本

ConcurrentHashMap由一个Segment[]数组组成，数组元素是一个数组+链表的结构。分段锁设计，下面为结构

java1.8版本

jdk8版本的ConcurrentHashMap相对于jdk7版本，发送了很大改动，jdk8直接抛弃了Segment的设计，采用了较为轻捷的Node + CAS + Synchronized设计，保证线程安全。

基本使用

new创建即可：

public static void main(String[] args) throws InterruptedException { //定义		
		ConcurrentHashMap Map map = new ConcurrentHashMap(); 
		for (int i = 0; i < 10; i++) {
		    new Thread(new Runnable() {
		    	@Override
		    	public void run() {
		    	//多线程下的put可以放心使用
		    	map.put(UUID.randomUUID().toString(), "1"); } }).start();
		 }
		 Thread.sleep(3000); System.out.println(map); 
}

实现原理

流程图

1.7是分段锁，上面阐述过，1.8采用的是cas + synchronized 操作，具体看代码：

代码

​    final V putVal(K key, V value, boolean onlyIfAbsent) {
​        if (key == null || value == null) throw new NullPointerException();
​        int hash = spread(key.hashCode());//key取hash
​        int binCount = 0;
​        for (Node<K,V>[] tab = table;;) {//循环直到成功
​            Node<K,V> f; int n, i, fh; K fk; V fv;
​            if (tab == null || (n = tab.length) == 0)
​                tab = initTable();//表为空的话，初始化表
​            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
​                //cas在这里！！！
​                //插槽为空，cas插入元素，看下面的 casTabAt 方法
​                //比较是否为null，如果null才会设置并break，否则到else
​                if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
​                    break;
​            }
​            
​            //...
​            
​            else {
​                V oldVal = null;
​                //synchronized 在这里！！！
​                //插槽不为空，说明被别的线程put抢占了槽
​                //那就加锁，锁的是当前插槽上的头节点f（类似分段锁）
​                synchronized (f) {
​                    if (tabAt(tab, i) == f) {
​                        if (fh >= 0) {
​                            binCount = 1;
​                            //沿着当前插槽的Node链往后找
​                            for (Node<K,V> e = f;; ++binCount) {
​                                K ek;
​                                //如果找到相同key，说明之前put过，覆盖
​                                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;
​                                //否则，新key，新Node插入到最后
​                                if ((e = e.next) == null) {
​                                    pred.next = new Node<K,V>(hash, key, value);
​                                    break;
​                                }
​                            }
​                        }
​                        //如果是红黑树，说明已经转化过，按树的规则放入Node
​                        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;
​                            }
​                        }
​                        else if (f instanceof ReservationNode)
​                            throw new IllegalStateException("Recursive update");
​                    }
​                }
​                if (binCount != 0) {
​                    //如果节点数达到临界值，链表转成树
​                    if (binCount >= TREEIFY_THRESHOLD)
​                        treeifyBin(tab, i);
​                    if (oldVal != null)
​                        return oldVal;
​                    break;
​                }
​            }
​        }
​        addCount(1L, binCount);
​        return null;
​    }
​    
​    //compareAndSetObject，比较并插入，典型CAS操作
​    static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
​                                        Node<K,V> c, Node<K,V> v) {
​        return U.compareAndSetObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
​    }

//get操作无锁
//Node的val和next是用volatile修饰的
//多线程环境下线程A修改结点的val或者新增节点的时候是对线程B可见的
public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    //key取hash
    int h = spread(key.hashCode());
  	//1.判断table是不是空的，2.当前桶上是不是空的
  	//如果为空，返回null
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
      	//找到对应hash槽的第一个node，如果key相等，返回value
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        
      	//...
        
      	//逐个遍历，比对key，找到后返回value
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    //遍历完还没找到，返回null
    return null;
}

总结：

put过程：

1. 根据key的hash值定位到桶位置 如果table为空if，先初始化table。
2. 如果table当前桶里没有node，cas添加元素。成功则跳出循环，失败则进入下一轮for循环。
3. 如果桶的位置不为空，遍历该桶的链表或者红黑树，若key已存在，则覆盖，不存在则将key插入到链表或红黑树 的尾部。

get过程：

1. 根据key的hash值定位到桶位置。
2. map是否初始化，没有初始化则返回null
3. 定位的桶是否有头结点，没有返回null
4. 遍历桶对应的链表或者红黑树，使用equals方法进行比较。key相同则返回value,不存在则返回null

注意！

注意正确理解ConcurrentHashMap线程安全这个问题。看一个典型案例：

package com.itheima;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class BadConcurrent {


    public static void main(String[] args) throws InterruptedException {
        Map<String,Integer> map = new ConcurrentHashMap();
        map.put("val",0);

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                int v = map.get("val");
                v++;
                try {
                    Thread.currentThread().sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                map.put("val",v);
            }).start();
        }

        Thread.sleep(3000);
        System.out.println(map);
    }
}

结果：

结论：ConcurrentHashMap只是在多线程put的时候进行加锁，不能保证get和put的原子性。