ConcurrentHashMap底层实现原理

m0_51986692

已于 2022-11-15 12:12:22 修改

阅读量126

点赞数 1

文章标签： java 开发语言

于 2022-10-25 12:07:19 首次发布

本文链接：https://blog.csdn.net/m0_51986692/article/details/127510889

版权

为什么不使用HashTable

HashTable 底层通过 synchronized 保证线程安全性问题

保证线程安全性问题---加上锁---发生锁的竞争

HashTable 当多个线程在访问 get或者put操作的时候

会发生this锁的竞争，多个线程竞争锁最终只会有一个

线程获取到this锁，获取不到的this锁可能会阻塞等待。

最终将我们的 HashTable 中 get 或者put方法改成

单线程执行效率是非常的低。

在多线程的情况下不推荐使用 HashTable ConcurrentHashMap

1.使用传统HashTable保证线程问题，是采用synchronized锁将整个HashTable中的数组锁住，

在多个线程中只允许一个线程访问Put或者Get，效率非常低，但是能够保证线程安全问题。

2.Jdk官方不推荐在多线程的情况下使用HashTable或者HashMap，建议使用ConcurrentHashMap分段HashMap，效率非常高。

核心思想：减少多个线程锁竞争不会在访问同一个HashTable

ConcurrentHashMap 1.7底层实现原理

ConcurrentHashMap将一个大的HashTable集合拆分成n多个不同的小的HashTable（Segment），默认的情况下是分成16个不同的Segment。每个Segment中都有自己独立的HashEntry<K,V>[] table；

纯手写 ConcurrentHashMap 1.7

public class MayiktConcurrentHashMap<K, V> {
    private Hashtable<K, V>[] segments;

    public MayiktConcurrentHashMap() {
        // 初始化segments 数组
        segments = new Hashtable[16];
        for (int i = 0; i < segments.length; i++) {
            segments[i] = new Hashtable<>();
        }
    }

    public void put(K k, V v) {
        // 计算key 存放具体 的Hashtable
        int segmentIndex = k.hashCode() % segments.length;
        Hashtable<K, V> hashtable = segments[segmentIndex];
        hashtable.put(k, v);
    }

    public V get(K k, V v) {
        int segmentIndex = k.hashCode() % segments.length;
        Hashtable<K, V> hashtable = segments[segmentIndex];
        return hashtable.get(k);
    }

    public static void main(String[] args) {
        HashMap<Object, Object> hashMap = new HashMap<>();
        hashMap.put("a", "a");
        hashMap.put(97, 97);
        System.out.println(hashMap.get("a"));
        System.out.println(hashMap.get(97));
    }
}

ConcurrentHashMap 底层采用分段锁设计将一个大的HashTable线程安全的集合

拆分成n多个小的 HashTable集合，默认初始化16个小的HashTable集合。

如果同时16个线程最终计算index值落地到不同的小的HashTable集合不会发生锁的竞争，同时可以支持16个线程访问ConcurrentHashMap 写的操作，效率非常高。

ConcurrentHashMap 1.7版本需要计算出2次 index值。

第一次计算index= 计算key存放到具体小的HashTable

第二次计算index= 计算key存放到具体小的HashTable，对应具体数组 index位置。

HashTable----数组+链表实现

ConcurrentHashMap 1.7

就是将一个大的HashTable集合拆分成n多个小的

HashTable集合默认16个。----分段锁设计

在多线程的情况下访问到我们的

ConcurrentHashMap 1.7版本做写的操作