栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

JDK7中ConcurrentHashMap源码解析

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

JDK7中ConcurrentHashMap源码解析

1. hashMap中扩容

transfer时可能出现循环链表问题

1. 使用头插法

hashMap是并发不安全的,hashTable是并发安全,使用synchronized保证线程安全。

hashTable保证线程安全的put方法实例:

        public synchronized V put(K key, V value) {

void addEntry(int hash, K key, V value, int bucketIndex) {
//如果hashMap大小大于等于阈值并且数据元素不为空扩容       
if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);//计算数组下标位置
        }

        createEntry(hash, key, value, bucketIndex);
    }

//扩容
void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        //将老数组元素放入新数组
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

//转移老数组元素,双重循环遍历数组和链表
void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry e : table) {
            while(null != e) {
                Entry next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

1.1 get() (TODO)

1.2 remove问题

remove最后一个时报错:Exception in thread "main"java.util.ConcurrentModificationException

解决方法:调用迭代器的remove方法

错误发生原因:调用map.remove(key)方法时modCount会++于是在调用hashmap的nextEntry()时报错。

if (modCount != expectedModCount)

        throw new ConcurrentModificationException();

而解决方法使用迭代器remove方法时hashmap会重新赋值

expectedModCount = modCount;
import java.util.HashMap;
import java.util.Iterator;

public class HashMapTest {

    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        map.put("1","1");
        map.put("2","2");

//        for(String key:map.keySet()){
//            if("1".equals(key)){
//                map.remove(key);
//            }
//        }

//        for(String key:map.keySet()){
//            if(key.equals("2")){
//                map.remove(key);//Exception in thread "main" java.util.ConcurrentModificationException
//            }
//        }

        //上述代码编译后代码
        Iterator i$ = map.keySet().iterator();

        while(i$.hasNext()) {
            String key = (String)i$.next();
            if (key.equals("2")) {
//                map.remove(key);//Exception in thread "main" java.util.ConcurrentModificationException
                //解决方法调用iterator的remove方法
                i$.remove();
            }
        }


    }
}
2. jdk7-cocurrentHashMap

cocurrentHashMap采用分段思想,segment,里面会有一个一个的hashEntry数组组成,segment继承reentrantLock,所以只能保证线程安全的。

2.1 构造方法
DEFAULT_INITIAL_CAPACITY:默认初始大小16
DEFAULT_LOAD_FACTOR:0.75f,作为一个计算系数吧!
DEFAULT_CONCURRENCY_LEVEL:并发级别,默认16
public ConcurrentHashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
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 s0 =
            new Segment(loadFactor, (int)(cap * loadFactor),
                             (HashEntry[])new HashEntry[cap]);
        Segment[] ss = (Segment[])new Segment[ssize];
        UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
        this.segments = ss;
    }
 2.2 put方法

public V put(K key, V value) {
        Segment s;
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key);
        int j = (hash >>> segmentShift) & segmentMask;
        if ((s = (Segment)UNSAFE.getObject          // nonvolatile; recheck
             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
            s = ensureSegment(j);
        return s.put(key, hash, value, false);
    }
2.3 使用UNsafe解决线程安全问题实例(TODO)

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/936154.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号