ConcurrentHashMap源码学习

参数及其含义

存储对象的数组。volatile用于保证table变化后可以立刻被看到。

java 复制代码

transient volatile Node<K,V>[] table;

用于table中元素计数。volatile关键字用于保证可见性。同时为避免数据不一致，使用cas操作进行修改。

java 复制代码

private transient volatile long baseCount;

用于table中每个单元中节点个数的计数。大小是2的倍数

java 复制代码

private transient volatile CounterCell[] counterCells;

节点，用于存储每个key，value的类。其中key和hash在赋值后不允许修改。value和next指针修改后需要立即可见。

java 复制代码

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        volatile V val;
        volatile Node<K,V> next;

        Node(int hash, K key, V val, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.val = val;
            this.next = next;
        }

        public final K getKey()       { return key; }
        public final V getValue()     { return val; }
        public final int hashCode()   { return key.hashCode() ^ val.hashCode(); }
        public final String toString(){ return key + "=" + val; }
        public final V setValue(V value) {
            throw new UnsupportedOperationException();
        }

        public final boolean equals(Object o) {
            Object k, v, u; Map.Entry<?,?> e;
            return ((o instanceof Map.Entry) &&
                    (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
                    (v = e.getValue()) != null &&
                    (k == key || k.equals(key)) &&
                    (v == (u = val) || v.equals(u)));
        }

        /**
         * Virtualized support for map.get(); overridden in subclasses.
         */
        Node<K,V> find(int h, Object k) {
            Node<K,V> e = this;
            if (k != null) {
                do {
                    K ek;
                    if (e.hash == h &&
                        ((ek = e.key) == k || (ek != null && k.equals(ek))))
                        return e;
                } while ((e = e.next) != null);
            }
            return null;
        }
    }

节点特殊状态的hash值。

java 复制代码

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

进行resize控制。用于表的初始化和resize控制。如果是负数，说明table正在被初始化或者resize：-1表示初始化，否则-（1+正在resize的线程数）。否则，当表为空的时候，默认值为0。在初始化之后，保存下一个计数值，用于resize控制。

java 复制代码

private transient volatile int sizeCtl;

常用方法

size()方法

java 复制代码

public int size() {
    long n = sumCount();
    return ((n < 0L) ? 0 :
            (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
            (int)n);
}

如果n的范围在0到Integer.MAX_VALUE之间，返回n。如果小于0，返回0；如果大于Integer.MAX_VALUE，返回Integer.MAX_VALUE。

java 复制代码

final long sumCount() {
    CounterCell[] as = counterCells; CounterCell a;
    long sum = baseCount;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

sumCount统计所有元素的个数。首先sum赋值baseCount，获取数组中元素个数；然后遍历counterCells，统计冲突的元素个数。

get()方法

java 复制代码

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;
}

Node<K,V>[] tab;用来对数组进行操作。
Node<K,V> e指向当前key在数组中对应的对象。
Node<K,V> p用于表示在链表中查找的对象。
int n用于表示在数组的长度。
eh用于表示在key对应对象的哈希值。
ek用于表示在key对应对象的key。

如果数组不为空且key在数组中对应的对象的key和hash值相等，则返回对象的值。

否则说明存在冲突。如果eh小于0。条件成立：即，hash小于0

分2种情况，是树或者正在扩容,需要借助find方法寻找元素，find的寻找方式依据Node的不同子类有不同的实现方式:

情况一：eh=-1 是fwd结点 -> 说明当前table正在扩容，且当前查询的这个桶位的数据已经被迁移走了，需要借助fwd结点的内部方法find去查询

情况二：eh=-2 是TreeBin节点 -> 需要使用TreeBin 提供的find方法查询

否则说明是链表。遍历链表判断数据是否是要获取的数据。

put方法

putVal方法

java 复制代码

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;
}

如果key为空，或者val为空就抛出异常。
if (tab == null || (n = tab.length) == 0) tab = initTable();如果数组为空，或者数组长度为0，就初始化table。
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null)获取数组中i下标的数据是否为空。为空就进行修改。
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))casTabAt方法，判断tab中i指向的对象是否为空，为空就将new的Node更新到当前位置。
(fh = f.hash) == MOVED当前key对应的节点被移动了。调用helpTransfer(tab, f);方法协助进行扩容。

否则存在多个key的hash值相同的情况。synchronized (f)对对象f加锁，
if (tabAt(tab, i) == f) { if (fh >= 0) {判断tab是否发生变化了，即tab中索引i对应的对象是否还为f。如果tab没有变化并且fh>=0，说明节点不是fwd结点、TreeBin节点，是链表。

遍历链表节点，如果key存在，则覆盖原值；如果key不存在，在尾部添加节点。

如果f节点是TreeBin节点，在树中插入节点。
if (binCount != 0)说明存在插入的位置是链表或者是树，
if (binCount >= TREEIFY_THRESHOLD)说明是链表需要转树结构。
if (oldVal != null)说明原来的key已经存在了。返回原来的值。
addCount(1L, binCount);走到这里说明执行了插入。binCount对应计数加一。

initTable方法

java 复制代码

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;
}

while ((tab = table) == null || tab.length == 0)如果table是空，说明需要执行resize流程。
if ((sc = sizeCtl) < 0)说明有线程正在初始化或者进行resize。
if (U.compareAndSwapInt(this, SIZECTL, sc, -1))对sizectl减一，表明在初始化过程中了。把变量赋值给SIZECTL。
if ((tab = table) == null || tab.length == 0)表为空，或者长度为0需要进行初始化。
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;如果sc大于0，说明创建map对象时传递了初始化容量的参数。否则sc==0，就给n赋默认值。
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];创建长度为n的临时table。
table = tab = nt;table赋值。
sc = n - (n >>> 2);等价于数组容量*阈值，即数组中存储的元素个数。n>>>2是n右移两位，相当于除以4。n-n>>>2相当于n*0.75。
finally中sizeCtl赋值。

最后返回初始化的表table。