java基础-集合-ConcurrentHashMap源码学习

putVal

final V putVal(K key, V value, boolean onlyIfAbsent) {
		// 不允许 key或value 为null，HashMap允许 key 为null
        if (key == null || value == null) throw new NullPointerException();
        // 计算hash，将key的hashCode的高16位和低16位进行异或，增大随机性，HASH_BITS为0x7fffffff，二进制为11111111111111111111111111111111，进行&操作，如果两个都是1则为1，否则为0，这样为1和为0的概率都为百分之五十，这样做也是为了增大hash的随机性，减少hash碰撞的几率
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh; K fk; V fv;
            // 判断tab是不是空或者tab的长度是否等于0，如果满足条件，则说明数组没有初始化，需要进行数组的初始化
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            // 当前数组上的位置的元素为null，则创建一个Node使用CAS操作将元素放到桶中，并且终止循环。
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
                    break;                   // no lock when adding to empty bin
            }
            // 当前桶节点正在处于MOVED状态，说明正在扩容，那么就帮助进行扩容。
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            // 需要替换已有值，则替换，否则不替换
            else if (onlyIfAbsent // check first node without acquiring lock
                     && fh == hash
                     && ((fk = f.key) == key || (fk != null && key.equals(fk)))
                     && (fv = f.val) != null)
                return fv;
            else {
                V oldVal = null;
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                    	//     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
						// fh >= 0 此节点为链表结构
                        if (fh >= 0) {
                            binCount = 1;
                            // 循环链表，在尾节点上添加元素，此时binCount在自增，binCount为后续判断是否将链表转为树结构的条件之一
                            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);
                                    break;
                                }
                            }
                        }
                        // 此节点为树结构
                        else if (f instanceof TreeBin) {
                            Node<K,V> p;
                            binCount = 2;
                            // 将元素添加到树节点上，若p != null，说明要放置的的节点上已有值,
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                // 需要替换已有值，则替换，否则不替换
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                        // TODO
                        else if (f instanceof ReservationNode)
                            throw new IllegalStateException("Recursive update");
                    }
                }
                
                if (binCount != 0) {
                	// 节点元素为链表且链表上元素总数>=8
                    if (binCount >= TREEIFY_THRESHOLD)
                    	// 树化tab
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

initTable

private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        // 首先判断table为空时，会对数组进行初始化
        while ((tab = table) == null || tab.length == 0) {
        	// sizeCtl默认值为0，如果sizeCtl小于0，根据sizeCtl的注释可以得知，说明table正在初始化，如果正在初始化，则当前线程让出CPU执行权，因为只能有一个线程去初始化table。
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin
            // 如果sizeCtl大于0，则尝试使用CAS进行替换将SIZECTL,替换为-1，如果替换成功，就由当前线程去做table的初始化。
            else if (U.compareAndSetInt(this, SIZECTL, sc, -1)) {
                try {
                	// 再次判断table为空时，对数组进行初始化
                    if ((tab = table) == null || tab.length == 0) {
                    	// 因为默认sc为0，默认容量为DEFAULT_CAPACITY 16
                        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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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());
        // table不为空，table.length>0, hash下表桶上有元素
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {
            // 当前桶节点hash值和计算的hash相等，并且key值也相等，则返回对应的value。
            if ((eh = e.hash) == h) {
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    return e.val;
            }
            // 如果桶节点的hash值小于0，则说明是红黑树，使用TreeNode的find方法，对红黑树的节点进行遍历，直到找到key相等的元素返回对应value。
            else if (eh < 0)
                return (p = e.find(h, key)) != null ? p.val : null;
            // 桶节点下面不是红黑树，说明是一个链表，对链表进行遍历，直到遍历到key相等的元素返回对应value。
            while ((e = e.next) != null) {
                if (e.hash == h &&
                    ((ek = e.key) == key || (ek != null && key.equals(ek))))
                    return e.val;
            }
        }
        return null;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23