70%的Java程序员不知道为啥 ConcurrentHashMap 读操作不需要加锁?

作者:上帝爱吃苹果

目录

1.ConcurrentHashMap的简介
2.get操作源码
3.volatile登场
4.是加在数组上的volatile吗?
5.用volatile修饰的Node
6.总结

我们知道,ConcurrentHashmap(1.8)这个并发集合框架是线程安全的,当你看到源码的get操作时,会发现get操作全程是没有加任何锁的,这也是这篇博文讨论的问题——为什么它不需要加锁呢?

ConcurrentHashMap的简介
我想有基础的同学知道在jdk1.7中是采用Segment + HashEntry + ReentrantLock的方式进行实现的,而1.8中放弃了Segment臃肿的设计,取而代之的是采用Node + CAS + Synchronized来保证并发安全进行实现。
JDK1.8的实现降低锁的粒度,JDK1.7版本锁的粒度是基于Segment的,包含多个HashEntry,而JDK1.8锁的粒度就是HashEntry(首节点)
JDK1.8版本的数据结构变得更加简单,使得操作也更加清晰流畅,因为已经使用synchronized来进行同步,所以不需要分段锁的概念,也就不需要Segment这种数据结构了,由于粒度的降低,实现的复杂度也增加了
JDK1.8使用红黑树来优化链表,基于长度很长的链表的遍历是一个很漫长的过程,而红黑树的遍历效率是很快的,代替一定阈值的链表,这样形成一个最佳拍档

get操作源码
首先计算hash值,定位到该table索引位置,如果是首节点符合就返回
如果遇到扩容的时候,会调用标志正在扩容节点ForwardingNode的find方法,查找该节点,匹配就返回
以上都不符合的话,就往下遍历节点,匹配就返回,否则最后就返回null

//会发现源码中没有一处加了锁
public V get(Object key) {
 Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
 int h = spread(key.hashCode()); //计算hash
 if ((tab = table) != null && (n = tab.length) > 0 &&
 (e = tabAt(tab, (n - 1) & h)) != null) {//读取首节点的Node元素
 if ((eh = e.hash) == h) { //如果该节点就是首节点就返回
 if ((ek = e.key) == key || (ek != null && key.equals(ek)))
 return e.val;
 }
 //hash值为负值表示正在扩容,这个时候查的是ForwardingNode的find方法来定位到nextTable来
 //eh=-1,说明该节点是一个ForwardingNode,正在迁移,此时调用ForwardingNode的find方法去nextTable里找。
 //eh=-2,说明该节点是一个TreeBin,此时调用TreeBin的find方法遍历红黑树,由于红黑树有可能正在旋转变色,所以find里会有读写锁。
 //eh>=0,说明该节点下挂的是一个链表,直接遍历该链表即可。
 else if (eh < 0)
 return (p = e.find(h, key)) != null ? p.val : null;
 while ((e = e.next) != null) {//既不是首节点也不是ForwardingNode,那就往下遍历
 if (e.hash == h &&
 ((ek = e.key) == key || (ek != null && key.equals(ek))))
 return e.val;
 }
 }
 return null;
}

get没有加锁的话,ConcurrentHashMap是如何保证读到的数据不是脏数据的呢?
volatile登场
对于可见性,Java提供了volatile关键字来保证可见性、有序性。但不保证原子性。
普通的共享变量不能保证可见性,因为普通共享变量被修改之后,什么时候被写入主存是不确定的,当其他线程去读取时,此时内存中可能还是原来的旧值,因此无法保证可见性。
volatile关键字对于基本类型的修改可以在随后对多个线程的读保持一致,但是对于引用类型如数组,实体bean,仅仅保证引用的可见性,但并不保证引用内容的可见性。。
禁止进行指令重排序。
背景:为了提高处理速度,处理器不直接和内存进行通信,而是先将系统内存的数据读到内部缓存(L1,L2或其他)后再进行操作,但操作完不知道何时会写到内存。
如果对声明了volatile的变量进行写操作,JVM就会向处理器发送一条指令,将这个变量所在缓存行的数据写回到系统内存。但是,就算写回到内存,如果其他处理器缓存的值还是旧的,再执行计算操作就会有问题。
在多处理器下,为了保证各个处理器的缓存是一致的,就会实现缓存一致性协议,当某个CPU在写数据时,如果发现操作的变量是共享变量,则会通知其他CPU告知该变量的缓存行是无效的,因此其他CPU在读取该变量时,发现其无效会重新从主存中加载数据。

总结下来:
第一:使用volatile关键字会强制将修改的值立即写入主存;
第二:使用volatile关键字的话,当线程2进行修改时,会导致线程1的工作内存中缓存变量的缓存行无效(反映到硬件层的话,就是CPU的L1或者L2缓存中对应的缓存行无效);
第三:由于线程1的工作内存中缓存变量的缓存行无效,所以线程1再次读取变量的值时会去主存读取。

是加在数组上的volatile吗?

/**
     * The array of bins. Lazily initialized upon first insertion.
     * Size is always a power of two. Accessed directly by iterators.
     */
 transient volatile Node<K,V>[] table;

我们知道volatile可以修饰数组的,只是意思和它表面上看起来的样子不同。举个栗子,volatile int array[10]是指array的地址是volatile的而不是数组元素的值是volatile的.

用volatile修饰的Node
get操作可以无锁是由于Node的元素val和指针next是用volatile修饰的,在多线程环境下线程A修改结点的val或者新增节点的时候是对线程B可见的。

static class Node<K,V> implements Map.Entry<K,V> {
 final int hash;
 final K key;
 //可以看到这些都用了volatile修饰
 volatile V val;
 volatile Node<K,V> next;

 Node(int hash, K key, V val, Node<K,V> next) {
 this.hash = hash;
 this.key = key;
 this.val = val;
 this.next = next;
 }

 public final K getKey() { return key; }
 public final V getValue() { return val; }
 public final int hashCode() { return key.hashCode() ^ val.hashCode(); }
 public final String toString(){ return key + "=" + val; }
 public final V setValue(V value) {
 throw new UnsupportedOperationException();
 }

 public final boolean equals(Object o) {
 Object k, v, u; Map.Entry<?,?> e;
 return ((o instanceof Map.Entry) &&
 (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
 (v = e.getValue()) != null &&
 (k == key || k.equals(key)) &&
 (v == (u = val) || v.equals(u)));
 }

 /**
     * Virtualized support for map.get(); overridden in subclasses.
     */
 Node<K,V> find(int h, Object k) {
 Node<K,V> e = this;
 if (k != null) {
 do {
                K ek;
 if (e.hash == h &&
 ((ek = e.key) == k || (ek != null && k.equals(ek))))
 return e;
 } while ((e = e.next) != null);
 }
 return null;
 }
}

既然volatile修饰数组对get操作没有效果那加在数组上的volatile的目的是什么呢?
其实就是为了使得Node数组在扩容的时候对其他线程具有可见性而加的volatile

总结
在1.8中ConcurrentHashMap的get操作全程不需要加锁,这也是它比其他并发集合比如hashtable、用Collections.synchronizedMap()包装的hashmap;安全效率高的原因之一。
get操作全程不需要加锁是因为Node的成员val是用volatile修饰的和数组用volatile修饰没有关系。
数组用volatile修饰主要是保证在数组扩容的时候保证可见性。

欢迎大家一起交流,喜欢文章记得点个赞哟,感谢支持!

原文地址:https://blog.51cto.com/14442094/2427406

时间: 2024-10-08 08:43:59

70%的Java程序员不知道为啥 ConcurrentHashMap 读操作不需要加锁?的相关文章

写给在迷茫期的程序员(尤其是Java程序员)入行了一年,感觉不知道接下来该怎么做才能继续进步了,求指教

入行了一年,感觉不知道接下来该怎么做才能继续进步了,求指教(V2EX) @kafka0102 :做技术可以学的东西太多了,只是在不同的阶段做好不同的规划,要结合当前所做的事情去做更深入或广度的学习.以Java Web开发为例,至少可以拓展的点有: 1.Web框架的原理学习,比如Spring.Play等等,最好自己能写出个简易的MVC框架(几千行代码).这样至少对常用设计模式.反射等技术很熟练了. 2.优秀代码研读.比如Java集合类.JUnit.Spring等源码,写出源码分析,会有很多收获.源

聊聊阿里社招面试,谈谈“野生”Java程序员学习的道路

阿里社招面试都问什么? 和之前一样,文章一上来,我们先来谈谈阿里的社招面试都问什么,其实这个话题并不是什么秘密,所有来阿里面试过的同学,都能回答一二. 两年前的时候,笔者在文章里是这么回答的. 这个是让LZ最头疼的一个问题,也是群里的猿友们问的最多的一个问题. 说实话,LZ只能隐约想起并发.JVM.分布式.TCP/IP协议这些个关键字,具体的问题真的是几乎都没记住.而且就算LZ记住了,也告诉你了,你也背会了,但LZ觉得,在面试中,你被问到一模一样问题的可能性依然很小. 甚至,就算你运气好被问到了

Java程序员岗位

Java程序员岗位面试题有哪些? 1.面向对象的特征有哪些方面(1)抽象:抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面.抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用部分细节.抽象包括两个方面,一是过程抽象,二是数据抽象.(2)继承:继承是一种联结类的层次模型,并且允许和鼓励类的重用,它提供了一种明确表述共性的方法.对象的一个新类可以从现有的类中派生,这个过程称为类继承.新类继承了原始类的特性,新类称为原始类的派生类(子类),而原始类称为新类的

Java程序员面试题收集(6)

<!————————————————————————————基础题122道,代码题19道————————————————————————————> JAVA相关基础知识1.面向对象的特征有哪些方面1.抽象:抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面.抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用部分细节.抽象包括两个方面,一是过程抽象,二是数据抽象.2.继承:继承是一种联结类的层次模型,并且允许和鼓励类的重用,它提供了一种明确表述共性的方法

转载:java程序员如何拿到2万月薪

作者:匿名用户链接:https://www.zhihu.com/question/39890405/answer/83676977来源:知乎 著作权归作者所有.商业转载请联系作者获得授权,非商业转载请注明出处.作者:匿名用户链接:https://www.zhihu.com/question/39890405/answer/83676977来源:知乎 ---------------------------------------------------------------我是分割线------

两年Java程序员面试经验分享,从简历制作到面试总结!

前言 工作两年左右,实习一年左右,正式工作一年左右,其实挺尴尬的,高不成低不就.因此在面试许多公司,找到了目前最适合自己的公司之后.于是做一个关于面试的总结.希望能够给那些依旧在找工作的同学提供帮助. 面试 其实关于面试总结这块,我也看过不少文章,但是大部分都是关于面试题以及面试中的问题所谈.但是对于一个不擅长找工作的同学来说,其实在简历制作这一块很重要.因为简历没写好的话,连面试邀请都没,何谈面试呢.所以我准备谈谈我对简历制作这块的一些见解.如有不妥,欢迎指出! 简历制作 在写简历这方面,需要

Java程序员应该了解的10个面向对象设计原则

面向对象设计原则: 是OOPS(Object-Oriented Programming System,面向对象的程序设计系统)编程的核心,但大多数Java程序员追逐像Singleton.Decorator.Observer这样的设计模式,而不重视面向对象的分析和设计.甚至还有经验丰富的Java程序员没有听说过OOPS和SOLID设计原则,他们根本不知道设计原则的好处,也不知道如何依照这些原则来进行编程. 众所周知,Java编程最基本的原则就是要追求高内聚和低耦合的解决方案和代码模块设计.查看Ap

10招让你成为杰出的Java程序员(转)

如果你是一个热衷于技术的 Java 程序员, 那么下面的 10 个要点可以让你在众多 Java 开发人员中脱颖而出. 1. 拥有扎实的基础和深刻理解 OO 原则 对于 Java 程序员,深刻理解 Object Oriented Programming(面向对象编程)这一概念是必须的.没有 OOPS 的坚实基础,就领会不了像 Java 这些面向对象编程语言的美.光学习 OO 原则的定义用处不大,关键是要学会如何应用这些原则用一种 OO 的方式去设计解决方案.因此,我们应该对对象建模.继承.多态.设

当世界上只剩下一个Java程序员

公元2050年,世界上只剩下了一个Java程序员. 你可能要问了,别的人都去哪儿了?原因很简单, Java没落了. 大约在2030年左右,出现了一个叫做X的语言,它既能做系统级开发(操作系统.数据库.编译器),也能做服务器端的开发,手机端,Web端都不在话下. 更为重要的是,这个新的编程语言和人类的自然语言很接近,无论大人小孩,稍微一学,很快就可以来编程.于是排名前100的语言统统消失了, 程序员们都失业了. Java也不例外,这个昔日的霸主在留下了一堆庞大而复杂的系统以后就不见了. Java程