基于jdk1.8分析CurrentHashMap源码分析

本篇博客学习于https://www.cnblogs.com/zerotomax/p/8687425.html

?/currentHashMap集合同样是位于java.util包路径下面的
package java.util.concurrent;

//继承的包以及实现的接口分别都有哪些
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
    implements ConcurrentMap<K,V>, Serializable {
 
//允许的最大容量值
 private static final int MAXIMUM_CAPACITY = 1 << 30;

//默认的容量-注释上面指明必须是2的倍数Must be a power of 2
private static final int DEFAULT_CAPACITY = 16;
        
//跟hashMap集合中是一样的，负载因子为0.75浮点数
private static final float LOAD_FACTOR = 0.75f;
        
//链表中允许挂载的节点数为8      
static final int TREEIFY_THRESHOLD = 8; 
 
        
   static final int MOVED     = -1; // hash for forwarding nodes  代表正在初始化
    static final int TREEBIN   = -2; // hash for roots of trees    代表树形
    static final int RESERVED  = -3; // hash for transient reservations  代表扩容
    static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash  正常
        
//Node对象都是与HashMap一样的底层数据结构 
       
static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;  //hash值
        final K key;    //key
        volatile V val;  //value
        volatile Node<K,V> next;   //下个节点Node对象

        Node(int hash, K key, V val, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.val = val;
            this.next = next;
        }
        
        
        //原子性获取索引中的值
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
        return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
    }

        //cas设置值
    static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                        Node<K,V> c, Node<K,V> v) {
        return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
    }

        //原子性设置值
    static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
        U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
    }
        
        
        //数组复制之前的数组
         transient volatile Node<K,V>[] table;
        
        //备用的数组
        private transient volatile Node<K,V>[] nextTable;
        
        //初始化与扩容的标识数据 
        private transient volatile int sizeCtl;
        
        
        //无参构造没有做任何事情
         public ConcurrentHashMap() {
    }

主要是看添加元素的操作

//put方法主要是调用putVal方法
public V put(K key, V value) {
        return putVal(key, value, false);
    }

//该集合中不允许存储key为null与value为null的值，否则会抛出空指针异常
//首先判断是否初始化，没有就调用initTable方法初始化表
//判断查询出的索引处是否为null，为null就直接插入
//如果f.hash为-1数组复制时就将当前线程参与数组的复制
//不是就对数组中的元素加锁，遍历链表查询符合就覆盖，没有就添加到连尾
//如果为树结构就直接调用put方法


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) {
                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;
                                }
                            }
                        }
                        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方法 读操作没有对元素加锁

//代码逻辑与hashMap中的get方法实现一样的
public V get(Object key) {
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
        int h = spread(key.hashCode());
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {
            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;
    }

initTable初始化的方法

//根据sizeCtl的值判断是否在扩容操作，别的线程操作数组，是就停止执行
//sc大于0说明数组有记录，等于0是默认的，然后sizeCtl为sc的3/4值
private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) {
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    if ((tab = table) == null || tab.length == 0) {
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        @SuppressWarnings("unchecked")
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = tab = nt;
                        sc = n - (n >>> 2);
                    }
                } finally {
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }