public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
    return new SynchronizedMap<>(m);
}
private static class SynchronizedMap<K,V>
    implements Map<K,V>, Serializable {
    private static final long serialVersionUID = 1978198479659022715L;
    private final Map<K,V> m;     // Backing Map
    final Object      mutex;        // Object on which to synchronize
    SynchronizedMap(Map<K,V> m) {
        this.m = Objects.requireNonNull(m);
        mutex = this;
    }
    SynchronizedMap(Map<K,V> m, Object mutex) {
        this.m = m;
        this.mutex = mutex;
    }
    public int size() {
        synchronized (mutex) {return m.size();}
    }
    public boolean isEmpty() {
        synchronized (mutex) {return m.isEmpty();}
    }
    ............
}

劳务调派信息打点系统 以乱序执行" src="/uploads/allimg/c180914/153DE133MW0-11J8.jpg" />

抱负环境下，一个默认的ConcurrentHashMap可以同时接管16个线程举办写操纵（假如都是对差异Segment举办操纵的话）。

分段锁对付size()这样的全局操纵来说就没有任何浸染了，想要得出Entry的数量就需要遍历所有Segment，劳务派遣管理系统，得到所有的锁，然后再统计总数。事实上，ConcurrentHashMap会先试图利用无锁的方法统计总数，这个实验会举办3次，假如在相邻的2次计较中得到的Segment的modCount次数一致，代表这两次计较进程中都没有产生过修改操纵，那么就可以当做最终功效返回，不然，就要得到所有Segment的锁，从头计较size。

本文主要接头的是Java 8的ConcurrentHashMap，它与Java 7的实现不同较大。完全放弃了段的设计，而是变回与HashMap相似的设计，利用buckets数组与疏散链接法（同样会在高出阈值时树化，对付结构红黑树的逻辑与HashMap不同不大，只不外需要特别利用CAS来担保线程安详），锁的粒度也被细分到每个数组元素（小我私家认为这样做的原因是因为HashMap在Java 8中也实现了不少优化，纵然碰撞严重，也能担保必然的机能，并且Segment不只臃肿尚有弱一致性的问题存在），所以它的并发级别与数组长度相关（Java 7则是与段数相关）。

/**
 * The array of bins. Lazily initialized upon first insertion.
 * Size is always a power of two. Accessed directly by iterators.
 */
transient volatile Node<K,V>[] table;

寻址

ConcurrentHashMap的散列函数与HashMap并没有什么区别，同样是把key的hash code的高16位与低16位举办异或运算（因为ConcurrentHashMap的buckets数组长度也永远是一个2的N次方），然后将扰乱后的hash code与数组的长度减一（实际可会见到的最大索引）举办与运算，得出的功效等于方针地址的位置。

// 2^31 - 1，int范例的最大值
// 该掩码暗示节点hash的可用位，用来担保hash永远为一个正整数
static final int HASH_BITS = 0x7fffffff;
static final int spread(int h) {
    return (h ^ (h >>> 16)) & HASH_BITS;
}

下面是查找操纵的源码，实现较量简朴。

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)
            // eh < 0代表这是一个非凡节点（TreeBin或ForwardingNode）
            // 所以直接挪用find()举办遍历查找
            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;
}