翻了ConcurrentHashMap1.7 和1.8的源码,我总结了它们的主要区别。

ConcurrentHashMap

思考:HashTable是线程安全的,为什么不推荐使用?

HashTable是一个线程安全的类,它使用synchronized来锁住整张Hash表来实现线程安全,即每次锁住整张表让线程独占,相当于所有线程进行读写时都去竞争一把锁,导致效率非常低下。

1 ConcurrentHashMap 1.7

在JDK1.7中ConcurrentHashMap采用了数组+分段锁的方式实现

Segment(分段锁)-减少锁的粒度

ConcurrentHashMap中的分段锁称为Segment,它即类似于HashMap的结构,即内部拥有一个Entry数组,数组中的每个元素又是一个链表,同时又是一个ReentrantLock(Segment继承了ReentrantLock)。

1.存储结构

Java 7 版本 ConcurrentHashMap 的存储结构如图:

ConcurrnetHashMap 由很多个 Segment 组合,而每一个 Segment 是一个类似于 HashMap 的结构,所以每一个 HashMap 的内部可以进行扩容。但是 Segment 的个数一旦初始化就不能改变,默认 Segment 的个数是 16 个,所以可以认为 ConcurrentHashMap 默认支持最多 16 个线程并发。

2. 初始化

通过 ConcurrentHashMap 的无参构造探寻 ConcurrentHashMap 的初始化流程。

    /**
     * Creates a new, empty map with a default initial capacity (16),
     * load factor (0.75) and concurrencyLevel (16).
     */
    public ConcurrentHashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
    }
复制代码

无参构造中调用了有参构造,传入了三个参数的默认值,他们的值是。

    /**
     * 默认初始化容量,这个容量指的是Segment 的大小
     */
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    /**
     * 默认负载因子
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 默认并发级别,并发级别指的是Segment桶的个数,默认是16个并发大小
     */
    static final int DEFAULT_CONCURRENCY_LEVEL = 16;

Segment下面entryset数组的大小是用DEFAULT_INITIAL_CAPACITY/DEFAULT_CONCURRENCY_LEVEL求出来的。
复制代码

接着看下这个有参构造函数的内部实现逻辑。

@SuppressWarnings("unchecked")
public ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel) {
    // 参数校验
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    // 校验并发级别大小,大于 1<<16,重置为 65536
    if (concurrencyLevel > MAX_SEGMENTS)
        concurrencyLevel = MAX_SEGMENTS;
    // Find power-of-two sizes best matching arguments
    // 2的多少次方
    int sshift = 0;//控制segment数组的大小
    int ssize = 1;
    // 这个循环可以找到 concurrencyLevel 之上最近的 2的次方值
    while (ssize < concurrencyLevel) {
        ++sshift;//代表ssize左移的次数
        ssize <<= 1;
    }
    // 记录段偏移量
    this.segmentShift = 32 - sshift;
    // 记录段掩码
    this.segmentMask = ssize - 1;
    // 设置容量   判断初始容量是否超过允许的最大容量
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    // c = 容量 / ssize ,默认 16 / 16 = 1,这里是计算每个 Segment 中的类似于 HashMap 的容量
   //求entrySet数组的大小,这个地方需要保证entrySet数组的大小至少可以存储下initialCapacity的容量,假设initialCapacity为33,ssize为16,那么c=2,所以if语句是true,那么c=3,MIN_SEGMENT_TABLE_CAPACITY初始值是2,所以if语句成立,那么cap=4,所以每一个segment的容量初始为4,segment为16,16*4>33成立,entrySet数组的大小也需要是2的幂次方
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    //Segment 中的类似于 HashMap 的容量至少是2或者2的倍数
    while (cap < c)
        cap <<= 1;
    // create segments and segments[0]
    // 创建 Segment 数组,设置 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;
}
复制代码

总结一下在 Java 7 中 ConcurrnetHashMap 的初始化逻辑。

  1. 必要参数校验。
  2. 校验并发级别 concurrencyLevel 大小,如果大于最大值,重置为最大值。无参构造默认值是 16.
  3. 寻找并发级别 concurrencyLevel 之上最近的 2 的幂次方值,作为初始化容量大小,默认是 16
  4. 记录 segmentShift 偏移量,这个值为【容量 = 2 的N次方】中的 N,在后面 Put 时计算位置时会用到。默认是 32 - sshift = 28.
  5. 记录 segmentMask,默认是 ssize - 1 = 16 -1 = 15.
  6. 初始化 segments[0]默认大小为 2负载因子 0.75扩容阀值是 2*0.75=1.5,插入第二个值时才会进行扩容。
  1. 计算segment数组容量的大小。
  2. 计算entrySet数组的大小。
  3. 初始化segment数组,其中生成一个s0对象放在数组的第0个位置
  4. 为什么首先需要一个s0存储到数组的第一个位置?

因为初始化数组完成后数组元素都还是null值,以后每一次添加一个元素的话,需要封装为entrySet对象,还需要对entrySet数组的大小重新计算,如果把第一次的计算结果全部存储到S0中,那么以后的话只需要直接拿来使用即可,不需要重新计算。虽然Segment对象不同,但是对象中属性内容其实是一样的。

  1. Segment数组的长度第一次已经确定,以后不会在改变,扩容是局部扩容,只对setrySet数组的容量进行扩容。

3. put

接着上面的初始化参数继续查看

  • 0
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: ConcurrentHashMap 1.71.8区别主要在于性能和功能上的改进。具体来说,ConcurrentHashMap 1.8 在以下方面有所改进: 1. 内存占用:ConcurrentHashMap 1.8 的内存占用比 1.7 更小,因为它使用了更少的对象和更少的指针。 2. 并发性能:ConcurrentHashMap 1.8 在并发性能方面有所提升,因为它使用了更高效的算法和数据结构。 3. 扩容机制:ConcurrentHashMap 1.8 的扩容机制更加智能化,可以更好地避免冲突和竞争。 4. 锁粒度:ConcurrentHashMap 1.8 的锁粒度更细,可以更好地支持高并发环境。 总的来说,ConcurrentHashMap 1.8 是一个更加高效、更加智能化的并发哈希表,可以更好地满足多线程环境下的需求。 ### 回答2: ConcurrentHashMap是一个线程安全的Map实现,它可以支持高并发的读操作和一定程度的写操作并发。在Java8之前,ConcurrentHashMap的实现和功能都比较简单,但是在Java8中对其进行了很大的改进。 首先,Java8中的ConcurrentHashMap增加了一些新的方法,如forEachKey、forEachValue、forEachEntry、reduce等,这些方法都是为了更方便地对ConcurrentHashMap进行遍历和操作。 其次,Java8中的ConcurrentHashMap在实现上采用了一种新的方式——分段锁(Segment Locking)。在Java7及之前,ConcurrentHashMap中只有一个全局锁,所有的读写操作都要竞争这个锁,这样会影响并发性能。而在Java8中,ConcurrentHashMap被划分成多个独立的段(Segment),每个段内部拥有一把锁。这样,当不同的线程对不同的段进行读写操作时,可以并行地进行,大大提高了ConcurrentHashMap的并发性能。 此外,Java8中的ConcurrentHashMap内部也采用了一些新的技术来优化其性能,如CAS、红黑树等,在处理高并发读写时性能更为出色。 综上所述,Java8中的ConcurrentHashMap相比Java7及之前的版本,在功能和性能方面都有了大幅度的提升,更加适合于高并发场景下的使用。 ### 回答3: ConcurrentHashMapJava集合框架中的一个线程安全的哈希表,它可以在多线程环境下使用而不需要显式地进行同步控制。在Java 1.71.8版本中,ConcurrentHashMap都有一些区别。 1. 同步方式 Java 1.7中的ConcurrentHashMap使用分段锁来进行同步控制,即一个ConcurrentHashMap被分成多个段(Segment),每个段都有一个独立的锁来控制访问。不同的线程可以往不同的段中插入元素,从而避免了线程间的竞争。 而Java 1.8中的ConcurrentHashMap使用了CAS(Compare and Swap)算法进行同步控制。这种算法比分段锁更为轻量级,因为它不需要线程之间的协调,而是每个线程都可以自己完成同步操作。此外,Java 1.8中的ConcurrentHashMap使用了一种基于链表的算法来处理哈希冲突,可以大大减少哈希冲突带来的开销。 2. 空值检查 在Java 1.7中,当对一个不存在的键进行获取或删除操作时,需要先检查相应的值是否为null,因为ConcurrentHashMap不能存储null值,如果值为null说明该键不存在。但是,在多线程环境下,这种检查需要进行同步操作,会影响程序的性能。 而在Java 1.8中,ConcurrentHashMap增加了一种isNull()方法,用于判断键是否存在以及值是否为null。这种方式不需要进行同步操作,因此可以提高程序的性能。 3. 并发度的改进 在Java 1.7中,ConcurrentHashMap在创建时需要指定相应的并发度(concurrencyLevel),以确定分段锁的数量。如果并发度设置得不够大,会导致多个线程竞争同一个锁,从而影响程序的性能;而如果并发度设置得过大,会造成锁的浪费。 Java 1.8中的ConcurrentHashMap移除了并发度这一参数,转而使用更为动态的方式来确定分段锁的数量。这种方式可以根据实际线程并发数来自动计算分段锁的数量,从而提高程序的性能。 综上所述,Java 1.8中的ConcurrentHashMap相比Java 1.7中的版本在同步方式、空值检查以及并发度方面都有所改进,可以提供更为高效的多线程操作能力。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值