ConcurrentHashMap 原理解析

ConcurrentHashMap 原理解析

ConcurrentHashMap.class

其他配套信息，初始化构造函数

 

内部类  static class Segment<K,V> extends ReentrantReadWriteLock implements Serializable 

所有增删改

 

 

 

1，初始化： 构造函数创建segements空间，并且对每个segement创建table

2，操作：操作时根据key找到segement（内部类），

3，对于put操作等，引入就锁lock(读写锁)，先根据key进行hash算法找到segement，然后在桶中找到这个桶的table中的第一个，

再根据这第一个遍历，找到了就覆盖返回旧值，没找到就新增

 (由于这个table[index]存的是entry这是一个单链表结构，这样获取第一个（table[index]）之后可以马上对其遍历)

 transient volatile HashEntry<K,V>[] table;//忽略这个成员变量序列化

 

 

//由于这个table是内部类，每new Segment一个桶就有一个table变量在里面，由于就是属于这个内部类的所以类似threadlocal效果，

//对于大类将有一个内部类，那么大类操作这个内部类就相当于threadlocal变量

 

  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;

        }

        segmentShift = 32 - sshift;

        segmentMask = ssize - 1;

        this.segments = Segment.newArray(ssize);

 

        if (initialCapacity > MAXIMUM_CAPACITY)

            initialCapacity = MAXIMUM_CAPACITY;

        int c = initialCapacity / ssize;

        if (c * ssize < initialCapacity)

            ++c;

        int cap = 1;

        while (cap < c)

            cap <<= 1;

 

        for (int i = 0; i < this.segments.length; ++i)

            this.segments[i] = createSegment(cap, loadFactor);

    }

 

 protected Segment<K, V> createSegment(int initialCapacity, float lf) {

        return new Segment<K, V>(initialCapacity, lf);

    }

 

Segment(int initialCapacity, float lf) {

            loadFactor = lf;

            setTable(HashEntry.<K,V>newArray(initialCapacity));

        }

 

 

 

 void setTable(HashEntry<K,V>[] newTable) {

            threshold = (int)(newTable.length * loadFactor);

            table = newTable;

        }

 

 

 

 

  public V put(K key, V value) {

        if (value == null)

            throw new NullPointerException();

        int hash = hash(key.hashCode());

        return segmentFor(hash).put(key, hash, value, false);

    }

 

 

 

      public V put(K key, V value) {

        if (value == null)

            throw new NullPointerException();

        int hash = hash(key.hashCode());

        return segmentFor(hash).put(key, hash, value, false);

    }

    

    

    

    V put(K key, int hash, V value, boolean onlyIfAbsent) {

            writeLock().lock();

            try {

                int c = count;

                if (c++ > threshold) // ensure capacity

                    rehash();

                HashEntry<K,V>[] tab = table;

                int index = hash & (tab.length - 1);

                HashEntry<K,V> first = tab[index];

                HashEntry<K,V> e = first;

                while (e != null && (e.hash != hash || !key.equals(e.key)))

                    e = e.next;

 

                V oldValue;

                if (e != null) {

                    oldValue = e.value;

                    if (!onlyIfAbsent)

                        e.value = value;

                }

                else {

                    oldValue = null;

                    ++modCount;

                    tab[index] = new HashEntry<K,V>(key, hash, first, value);

                    count = c; // write-volatile

                }

                return oldValue;

            } finally {

                writeLock().unlock();

            }

        }