java并发性能陷阱-伪共享 - Powered by Discuz! Archiver

小猫他爹 發表於 2025-10-30 15:42:00

java并发性能陷阱--伪共享

缓存可以说是计算机领域最伟大的发明之一， 经常会有人问，缓存是越多越好么？ 一般人们都会斩钉截铁的回答不是。 至于为什么？ 往往无法直觉回答了，可能会从缓存一致性，空间占用等几个角度逐一分析。 今天就来看看由于一致性导致的缓存问题。 在之前的文章中，我们聊过JMM java的内存模型（一定要有所了解，不太清楚的同学可以看下前文链接https://www.cnblogs.com/jilodream/p/9452391.html），可以知道线程并不是直接读写内存，而是调用线程自己的工作空间。 但这只是一个逻辑模型，线程我们可以理解为cpu的核心，工作空间所对应的位置一般是指cpu的缓存。就像下图这样：
<img src="https://img2024.cnblogs.com/blog/704073/202510/704073-20251030151821958-2105278573.png" alt="jmmcpu" loading="lazy">
目前主流的cpu就是每个核心有自己的多级缓存，一般还会加一个共享缓存，
越靠近核，缓存越小，但越快，成本也越大。 java线程实际对应的就是这个核，工作空间对应的就是这个缓存。 如果你详细思考，就会考虑到缓存中的数据时如何加载变量的。毕竟变量又长有短，如何加载定位的？ 一般来说，我们将内存划分成若干的块，(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )每一块是64个字节（主流是这个大小） 同时我们将缓存划分成若干的缓存行，也是64个字节。 cpu每次加载时，不是按照某个变量加载，而是将已经划分好的整块内容直接加载到缓存行中。因为从数据的使用经验来看，一般我们在使用某个变量时，很大可能会使用邻近变量，这种缓存的预判加载，提高了缓存的命中率。
有小伙伴会有疑问，会不会不同核的缓存行加载的数据跨了内存块了，也就是A核的缓存行是 xyz变量，B核的缓存行是yza变量。这是不会的，缓存块是根据内存的地址和偏移量划分好的，不会根据不同核来划分不同的边界的。
<img src="https://img2024.cnblogs.com/blog/704073/202510/704073-20251030152005462-845435542.png" alt="cacheline1" loading="lazy">
做过缓存设计的同学肯定知道，在设计时一定要考虑数据一致性的问题。如果多份缓存以及主存之间的数据不一致，就无法并发处理，无法得到准确的结果。
（ps，cpu一般是通过MESI缓存一致性协议并且配合失效缓存队列等等来实现的，感兴趣的读者可以查下相关内容） 从前文中的java内存模型中可以知道，当volatile变量发生变化时，java通过内存屏障，来强制失效其它cpu核心中缓存。 但是在真实情况下，cpu是按照行来缓存变量的，而不是单个变量，此时标记失效的就是整个缓存行。那么就会出现类似一个情况： 线程1操作变量a，线程2操作变量b，根据缓存的加载机制 （1）两者的均加载同一段缓存行。 （2）当线程1 修改完变量a时，通知其它线程失效该缓存行 （3）线程2修改变量b，发现缓存行失效，重新加载缓存行，修改完变量b后，重新知会其它线程该行已经失效 这样当线程1每次修改变量a，线程2每次修改变量b时，当前缓存都不断的需要重新加载，本质上已经失去了缓存的意义，还增加了缓存状态控制，缓存重新加载的开销。 这种在相同的缓存行的多个变量，但是由于并发原因，导致缓存不断失效，无法利用缓存读取变量的场景，我们就称之为伪共享。（False Sharing）
<img src="https://img2024.cnblogs.com/blog/704073/202510/704073-20251030152058643-2028293432.png" alt="cacheline2" loading="lazy">
这种情况其实不仅仅是java，其它语言，甚至是多缓存的业务，都会有类似的问题。
即由于并发引起的缓存联动失效，即使对我当前业务没有实际影响，但是由于缓存一致性的协议设计，我们判断当前缓存已经脏了。我们就需要重新加载。缓存的优势丧失，成本却被无限放大。 就像下边这个例子：
缓存类：
<div class="cnblogs_code">
<pre>1 public class CacheA {
2 volatile inta;
3
4 volatile intb;
5 }</pre>
</div>
线程类：
<div class="cnblogs_code">
<pre> 1 public class Main {
 2 private static CacheA cache = new CacheA();
 3 private static final int TOTAL = 1000000;
 4
 5 public static void main(String[] args) {
 6 Runnable r1 = new Runnable() {
 7 @Override
 8 public void run() {
 9 long startTime = System.currentTimeMillis();
10 for (int i = 0; i < TOTAL; i++) {
11 cache.a = (i-99999)*(i+99999);
12 }
13 long endTime = System.currentTimeMillis(); // 结束时间（毫秒）
14 long cost = endTime - startTime; // 耗时（毫秒）
15
16 System.out.println("方法耗时1: " + cost + " 毫秒");
17 }
18 };
19
20 Runnable r2 = new Runnable() {
21 @Override
22 public void run() {
23 long startTime = System.currentTimeMillis();
24 for (int i = 0; i < TOTAL; i++) {
25 cache.b =(i-99999)*(i+99999);
26 }
27 long endTime = System.currentTimeMillis(); // 结束时间（毫秒）
28 long cost = endTime - startTime; // 耗时（毫秒）
29
30 System.out.println("方法耗时2: " + cost + " 毫秒");
31 }
32 };
33
34 Thread t1=new Thread(r1);
35 t1.start();
36
37 Thread t2=new Thread(r2);
38 t2.start();
39 }
40 }</pre>
</div>
代码逻辑是两个线程并发修改两个变量，这两个变量在同一个实例里边。
输出结果是这样的：
<div class="cnblogs_code">
<pre>Connected to the target VM, address: '127.0.0.1:58237', transport: 'socket'
方法耗时2: 19 毫秒
方法耗时1: 22 毫秒
Disconnected from the target VM, address: '127.0.0.1:58237', transport: 'socket'

Process finished with exit code 0</pre>
</div>
我们来修改代码，加上很多无效的变量，重新执行，
缓存类：
<div class="cnblogs_code">
<pre> 1 public class CacheB {
 2 volatile inta;
 3 long temp1=0;
 4 long temp2=0;
 5 long temp3=0;
 6 long temp4=0;
 7 long temp5=0;
 8 long temp6=0;
 9 long temp7=0;
10
11 volatile intb;
12 }</pre>
</div>
线程类：
<div class="cnblogs_code">
<pre> 1 public class Main {
 2 private static CacheB cache = new CacheB();
 3 private static final int TOTAL = 1000000;
 4
 5 public static void main(String[] args) {
 6 Runnable r1 = new Runnable() {
 7 @Override
 8 public void run() {
 9 long startTime = System.currentTimeMillis();
10 for (int i = 0; i < TOTAL; i++) {
11 cache.a = (i-99999)*(i+99999);
12 }
13 long endTime = System.currentTimeMillis(); // 结束时间（毫秒）
14 long cost = endTime - startTime; // 耗时（毫秒）
15
16 System.out.println("方法耗时1: " + cost + " 毫秒");
17 }
18 };
19
20 Runnable r2 = new Runnable() {
21 @Override
22 public void run() {
23 long startTime = System.currentTimeMillis();
24 for (int i = 0; i < TOTAL; i++) {
25 cache.b =(i-99999)*(i+99999);
26 }
27 long endTime = System.currentTimeMillis(); // 结束时间（毫秒）
28 long cost = endTime - startTime; // 耗时（毫秒）
29
30 System.out.println("方法耗时2: " + cost + " 毫秒");
31 }
32 };
33
34 Thread t1=new Thread(r1);
35 t1.start();
36
37 Thread t2=new Thread(r2);
38 t2.start();
39 }
40 }</pre>
</div>
执行结果如下：
<div class="cnblogs_code">
<pre>Connected to the target VM, address: '127.0.0.1:58389', transport: 'socket'
方法耗时1: 10 毫秒
方法耗时2: 10 毫秒
Disconnected from the target VM, address: '127.0.0.1:58389', transport: 'socket'

Process finished with exit code 0</pre>
</div>
是不是很神奇，我们给一个对象加了很多无用的变量，它居然变快了。而且性能还提升了不少。 这个优化的核心思路就是通过强制指定内存相对位置，将不相关的变量强制分配到不同的缓存行上，让缓存行不会因为当前不使用的缓存而被强制失效。 很多人也喜欢这样子写：
<div class="cnblogs_code">
<pre> private volatile long value;
private long p1, p2, p3, p4, p5, p6, p7;</pre>
</div>
通过手动补齐剩余字节，确保当前变量尽可能在一个缓存行上。 但是这样子写代码就很不方便了，(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )我们要增加很多无意义的字段，或者通过其它变量穿插起来。很容易被别人误改，误删，也影响代码最重要的阅读性。 因此java在8及以上的版本，增加了一个注解@Contended Contended 美英 v.竞争;认为;争夺
这个注解既可以用在类上，也可以用在变量上代码如下：
缓存类：
<div class="cnblogs_code">
<pre> 1 import jdk.internal.vm.annotation.Contended;
 2
 3 /**
 4 * @discription
 5*/
 6 public class CacheC {
 7 @Contended
 8 volatile inta;
 9
10 @Contended
11 volatile intb;
12 }</pre>
</div>
线程执行类：
<div class="cnblogs_code">
<pre> 1 public class Main {
 2 private static CacheC cache = new CacheC();
 3 private static final int TOTAL = 1000000;
 4
 5 public static void main(String[] args) {
 6 Runnable r1 = new Runnable() {
 7 @Override
 8 public void run() {
 9 long startTime = System.currentTimeMillis();
10 for (int i = 0; i < TOTAL; i++) {
11 cache.a = (i-99999)*(i+99999);
12 }
13 long endTime = System.currentTimeMillis(); // 结束时间（毫秒）
14 long cost = endTime - startTime; // 耗时（毫秒）
15
16 System.out.println("方法耗时1: " + cost + " 毫秒");
17 }
18 };
19
20 Runnable r2 = new Runnable() {
21 @Override
22 public void run() {
23 long startTime = System.currentTimeMillis();
24 for (int i = 0; i < TOTAL; i++) {
25 cache.b =(i-99999)*(i+99999);
26 }
27 long endTime = System.currentTimeMillis(); // 结束时间（毫秒）
28 long cost = endTime - startTime; // 耗时（毫秒）
29
30 System.out.println("方法耗时2: " + cost + " 毫秒");
31 }
32 };
33
34 Thread t1=new Thread(r1);
35 t1.start();
36
37 Thread t2=new Thread(r2);
38 t2.start();
39 }
40 }</pre>
</div>
同时我们要在jdk 启动时配上虚拟机参数：
-XX:-RestrictContended 
这个配置参数表示启用Contended注解
同时IDEA等(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )工具还会提示我们在配置中开启编译选项开关，允许代码访问jdk内部/隐藏的api
<div class="cnblogs_code">
<pre>--add-exports java.base/jdk.internal.vm.annotation=ALL-UNNAMED</pre>
</div>
使用注解后，执行结果如下
<div class="cnblogs_code">
<pre>Connected to the target VM, address: '127.0.0.1:56688', transport: 'socket'
方法耗时2: 11 毫秒
方法耗时1: 12 毫秒
Disconnected from the target VM, address: '127.0.0.1:56688', transport: 'socket'</pre>
</div>
和手动补齐的速度差不多。
手动补齐易于控制，但是影响代码阅读，交给虚拟机自动补齐。
通过注解交给jvm来强制填充隔离，又因为是内部API，不保证稳定性，因此大家根据自己情况来选用。
 

</div>
<div id="MySignature" role="contentinfo">

如果你觉得写的不错，欢迎转载和点赞。
转载时请保留作者署名jilodream/王若伊_恩赐解脱（博客链接：http://www.cnblogs.com/jilodream/ 
来源：https://www.cnblogs.com/jilodream/p/19177246

頁: [1]

琼殿技术论坛's Archiver

java并发性能陷阱--伪共享