ConcurrentHashMap源码解析

来源：互联网发布：全网分红系统源码编辑：程序博客网时间：2024/05/29 07:51

实现原理(Java7)

核心两个内部类，Segment与HashEntry
基于HashMap，在哈希桶数组的前面，又加了一个段，每个段，对应哈希桶的一部分。
采用二次Hash，第一次Hash，先对应key映射到指定的Segment段中，第二次Hash将其对应到不同的桶table中，每一个节点都是一个HashEntry<K, V>对象
为什么采用该种方式？
主要构造锁分离，使得当修改整个容器Map时，不会锁住整个容器，提高了并发能力。二次Hash，带来时间更长，如果不是考虑到并发，不建议使用。

HashMap类定义

public class HashMap<K,V> extends AbstractMap<K,V>    implements Map<K,V>, Cloneable, Serializable {}

继承抽象类AbstractMap<K,V>，提供了map的部分实现；HashMap类也继承了该类。
实现Map<K,V>接口，实现Cloneable，Serializable接口，能够进行克隆拷贝，序列化。

ConcurrentHashMap属性

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;     static final int MAXIMUM_CAPACITY = 1 << 30;    static final float DEFAULT_LOAD_FACTOR = 0.75f;    static final int TREEIFY_THRESHOLD = 8;    static final int UNTREEIFY_THRESHOLD = 6;    static final int MIN_TREEIFY_CAPACITY = 64;    static final int MAX_SEGMENTS = 1 << 16;    private static final int DEFAULT_CONCURRENCY_LEVEL = 16;

DEFAULT_INITIAL_CAPACITY
默认初始容量，当实例化对象时，未设置，则默认为16
MAXIMUM_CAPACITY
最大容量，若构造时，传入值过大，则将被该值替换，同时，当传入值大于MAXIMUM_CAPACITY，必须为2的偶数次幂，否则，报出异常Illegal initial capacity
DEFAULT_LOAD_FACTOR
默认负载值，实例化对象时，构造函数未指定，默认为0.75。该值表示含义，决定map容量扩容，当默认为HashMap(16, 0.75),默认容量为16，负载因子为0.75，当容量用到了16 * 0.75=12就进行扩容。若负载因子为1，就是16*1=16,当容量用到16才扩容。
DEFAULT_CONCURRENCY_LEVEL
用户估计的并发级别，默认16。最多有多少线程共同修改这个map，根据这个来确定Segment数组的大小。

在Java8中加入红黑树，又添加了如下属性

static final int TREEIFY_THRESHOLD = 8;static final int UNTREEIFY_THRESHOLD = 6;static final int MIN_TREEIFY_CAPACITY = 64;

TREEIFY_THRESHOLD
当链表长度大于该值时，转换为红黑树

针对CouncurrentHashMap的属性

final int segmentMask;final int segmentShift;final Segment<K,V>[] segments;

final int segmentMask;
段掩码
final int segmentShift;
段偏移量
主要用来定位segment

ConCurrentHashMap构造方法（Java7）

public ConcurrentHashMap(int initialCapacity,                             float loadFactor, int concurrencyLevel) {        if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)            throw new IllegalArgumentException();        if (concurrencyLevel > MAX_SEGMENTS)            concurrencyLevel = MAX_SEGMENTS;        // Find power-of-two sizes best matching arguments        int sshift = 0;        int ssize = 1;        while (ssize < concurrencyLevel) {            ++sshift;            ssize <<= 1;        }        this.segmentShift = 32 - sshift;        this.segmentMask = ssize - 1;        if (initialCapacity > MAXIMUM_CAPACITY)            initialCapacity = MAXIMUM_CAPACITY;        int c = initialCapacity / ssize;        if (c * ssize < initialCapacity)            ++c;        int cap = MIN_SEGMENT_TABLE_CAPACITY;        while (cap < c)            cap <<= 1;        // create segments and segments[0]        Segment<K,V> s0 =            new Segment<K,V>(loadFactor, (int)(cap * loadFactor),                             (HashEntry<K,V>[])new HashEntry[cap]);        Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];        UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]        this.segments = ss;    }public ConcurrentHashMap(int initialCapacity, float loadFactor) {this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL);}public ConcurrentHashMap(int initialCapacity) { this(initialCapacity,DEFAULT_LOAD_FACTOR,DEFAULT_CONCURRENCY_LEVEL);}public ConcurrentHashMap() {this(DEFAULT_INITIAL_CAPACITY,DEFAULT_LOAD_FACTOR,DEFAULT_CONCURRENCY_LEVEL);}

public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)
用户设置初始容量，负载因子，并发级别。
过程：
- 判断传入参数是否合理，不合理，抛出异常
- 设置段掩码segmentMask和段偏移量segmentShift
  依据concurrencyLevel，设置segments大小。通过ssize <<= 1，保证segments的大小是2的整数次幂，也就是说用户即使设置concurrencyLevel为13,15，通过构造方法后，也为16。sshift记录左移的次数。
- 处理初始总容量，若没有超过最大值1<<30，则为设置值
- 进行分段，每个segment数组元素存储的大小，即cap的值，也为2的幂利用均分，总容量/segment的大小（initialCapacity / ssize）每个segment最小容量为2，通过cap <<= 1，来逐渐增大，同时保证为2的整数次幂。
- 根据计算得来的参数，实例化Segment对象
其它的构造方法类似，只不过不是通过传入的值，采用默认值

ConCurrentHashMap核心方法（Java7）

获取元素

public V get(Object key) {        Segment<K,V> s; // manually integrate access methods to reduce overhead        HashEntry<K,V>[] tab;        int h = hash(key);        long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;        if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&            (tab = s.table) != null) {            for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile                     (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);                 e != null; e = e.next) {                K k;                if ((k = e.key) == key || (e.hash == h && key.equals(k)))                    return e.value;            }        }        return null;    }

public V get(Object key);
- 作用：通过key获取value，
- 通过Key计算指定Segment索引，使用UNSAFE.getObjectVolatile 获得Segment对象，然后遍历比较。使用volatile关键字，保证共享的东西的可见性
- 这里没有使用到锁同步，使用轻量级同步volatile原语sun.misc.Unsafe.getObjectVolatile(Object, long)，保证读到的是最新的对象。

添加元素

public V put(K key, V value) {        Segment<K,V> s;        if (value == null)            throw new NullPointerException();        int hash = hash(key);        int j = (hash >>> segmentShift) & segmentMask;        if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment            s = ensureSegment(j);        return s.put(key, hash, value, false);}final V put(K key, int hash, V value, boolean onlyIfAbsent) {            HashEntry<K,V> node = tryLock() ? null :                scanAndLockForPut(key, hash, value);            V oldValue;            try {                HashEntry<K,V>[] tab = table;                int index = (tab.length - 1) & hash;                HashEntry<K,V> first = entryAt(tab, index);                for (HashEntry<K,V> e = first;;) {                    if (e != null) {                        K k;                        if ((k = e.key) == key ||                            (e.hash == hash && key.equals(k))) {                            oldValue = e.value;                            if (!onlyIfAbsent) {                                e.value = value;                                ++modCount;                            }                            break;                        }                        e = e.next;                    }                    else {                        if (node != null)                            node.setNext(first);                        else                            node = new HashEntry<K,V>(hash, key, value, first);                        int c = count + 1;                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)                            rehash(node);                        else                            setEntryAt(tab, index, node);                        ++modCount;                        count = c;                        oldValue = null;                        break;                    }                }            } finally {                unlock();            }            return oldValue;        }

public V put(K key, V value)
过程：
- 判断Value是否为空，这里也说明了ConcurrentHashMap不能存入空值，不同于HashMap
- 定位Segment下标，使用UNSAFE获得对应索引的Segment对象
- 调用put(K key, int hash, V value, boolean onlyIfAbsent)方法存入
put(K key, int hash, V value, boolean onlyIfAbsent)
- 可重入锁进行tryLock可轮询请求锁，如果成功获取锁，则进行插入
- 若有其他线程也再对这个段进行更新操作，那么执行scanAndLockForPut进行重试。采用自旋锁。
- 定位table位置，(tab.length - 1) & hash
- 在指定索引的table中，若该存入值存在，替换若不存在，创建一个HashEntry存入

size()方法，获取存入元素个数

public int size() {        // Try a few times to get accurate count. On failure due to        // continuous async changes in table, resort to locking.        final Segment<K,V>[] segments = this.segments;        int size;        boolean overflow; // true if size overflows 32 bits        long sum;         // sum of modCounts        long last = 0L;   // previous sum        int retries = -1; // first iteration isn't retry        try {            for (;;) {                if (retries++ == RETRIES_BEFORE_LOCK) {                    for (int j = 0; j < segments.length; ++j)                        ensureSegment(j).lock(); // force creation                }                sum = 0L;                size = 0;                overflow = false;                for (int j = 0; j < segments.length; ++j) {                    Segment<K,V> seg = segmentAt(segments, j);                    if (seg != null) {                        sum += seg.modCount;                        int c = seg.count;                        if (c < 0 || (size += c) < 0)                            overflow = true;                    }                }                if (sum == last)                    break;                last = sum;            }        } finally {            if (retries > RETRIES_BEFORE_LOCK) {                for (int j = 0; j < segments.length; ++j)                    segmentAt(segments, j).unlock();            }        }        return overflow ? Integer.MAX_VALUE : size;    }

public int size()
- 每个Segment都有一个count属性记录，该Segment中存入的键值对数量。理论上通过叠加每个count就是size的值，但是在获取的过程中，可能该值正在被其它线程修改，因此，需要在叠加时上锁，保证读取的值时最新的，但是这里上锁，代价大。
- 这里采用的方法是，先不上锁，读取两次，分别叠加每个段的count与调整次数modCount，如果两次的调整次数modCount的和不相等，则说明在叠加count过程，其它线程发生了修改。重复三次这样操作之后，仍然是发现modCount不相等，则对每个Segment进行加锁统计。

ConcurrentHashMap在Java8的改变

多了的辅助类

参考这篇博客ConcurrentHashMap总结

Node
Node是最核心的内部类，它包装了key-value键值对，所有插入ConcurrentHashMap的数据都包装在这里面。它与HashMap中的定义很相似，但是但是有一些差别它对value和next属性设置了volatile同步锁(与JDK7的Segment相同)，它不允许调用setValue方法直接改变Node的value域，它增加了find方法辅助map.get()方法。
TreeNode
树节点类，另外一个核心的数据结构。当链表长度过长的时候，会转换为TreeNode。但是与HashMap不相同的是，它并不是直接转换为红黑树，而是把这些结点包装成TreeNode放在TreeBin对象中，由TreeBin完成对红黑树的包装。而且TreeNode在ConcurrentHashMap集成自Node类，而并非HashMap中的集成自LinkedHashMap.Entry<K,V>类，也就是说TreeNode带有next指针，这样做的目的是方便基于TreeBin的访问。
TreeBin
这个类并不负责包装用户的key、value信息，而是包装的很多TreeNode节点。它代替了TreeNode的根节点，也就是说在实际的ConcurrentHashMap“数组”中，存放的是TreeBin对象，而不是TreeNode对象，这是与HashMap的区别。另外这个类还带有了读写锁。

Java7与Java8中实现的区别

不采用segment而采用node，锁住node来实现减小锁粒度。
设计了MOVED状态当resize的中过程中线程2还在put数据，线程2会帮助resize。
使用3个CAS操作来确保node的一些操作的原子性，这种方式代替了锁。 sizeCtl的不同值来代表不同含义，起到了控制的作用。

后续针对Java8的改变，还没看太明白，待补充！

推荐博客：http://blog.csdn.net/u010723709/article/details/48007881

参考

http://blog.csdn.net/hitxueliang/article/details/24734861
http://www.importnew.com/15845.html
http://www.importnew.com/22007.html

阅读全文

0 0