伪共享
# 伪共享
从字面意思,我一开始理解的有点迷糊,一开始以为在内存中的变量是不可靠的呢,但是不是!它带来的影响是,会造成多线程操作同一个缓存行的变量性能下降,因为同一个缓存行的修改,只能能同时被一个线程修改,这样就失去了多线程的意义
伪共享的非标准定义为:缓存系统中是以缓存行(cache line)为单位存储的,当多线程修改互相独立的变量时,如果这些变量共享同一个缓存行,就会无意中影响彼此的性能,这就是伪共享。
# 缓存行
为什么会有缓存行?我个人觉得还是为了提高读取效率,就像搬水一样,是一个人一趟一趟搬有效率呢,还是直接开个卡车装一车水有效率呢?那肯定是后者。 缓存行通常为64个字节,而java的long类型对象为8个字节,想象一下,如果现在有一个long数组,他的容量是8个,当数组中的一个值被加载到缓存中,它会额外加载另外 7 个,以致你能非常快地遍历这个数组。
# 什么是伪共享
多个线程读写同一个缓存行的数据,使缓存行失效,那么缓存行和内存需要频繁交换数据
# 伪共享测试
接下来是多个线程操作同一个缓存行的测试
/**
* @author ggBall
* @version 1.0.0
* @ClassName FalseShareTest.java
* @Description TODO
* @createTime 2022年05月05日 16:23:00
*/
public class FalseShareTest implements Runnable {
public static int NUM_THREADS = 4;
public final static long ITERATIONS = 500L * 1000L * 1000L;
private final int arrayIndex;
private static VolatileLong[] longs;
public static long SUM_TIME = 0l;
public FalseShareTest(final int arrayIndex) {
this.arrayIndex = arrayIndex;
}
public static void main(final String[] args) throws Exception {
Thread.sleep(10000);
// 循环10次
for(int j=0; j<10; j++){
System.out.println(j);
if (args.length == 1) {
NUM_THREADS = Integer.parseInt(args[0]);
}
// 创建4个线程
longs = new VolatileLong[NUM_THREADS];
for (int i = 0; i < longs.length; i++) {
// 数组初始化
longs[i] = new VolatileLong();
}
final long start = System.nanoTime();
runTest();
final long end = System.nanoTime();
SUM_TIME += end - start;
}
System.out.println("平均耗时:"+SUM_TIME/10);
}
private static void runTest() throws InterruptedException {
Thread[] threads = new Thread[NUM_THREADS];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(new FalseShareTest(i));
}
for (Thread t : threads) {
t.start();
}
for (Thread t : threads) {
t.join();
}
}
public void run() {
// 修改数组
long i = ITERATIONS + 1;
while (0 != --i) {
longs[arrayIndex].value = i;
}
}
public final static class VolatileLong {
// 为了让线程对此变量具有可见性
public volatile long value = 0L;
public long p1, p2, p3, p4, p5, p6; //屏蔽此行
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
代码原理:初始化容量为四的数组,和四个线程,一个线程会去不断地更新的数组中的值。循环10次
测试分两次:
第一次屏蔽倒数第三行,这样VolatileLong
只有一个long对象,VolatileLong
占用 16个字节(类对象的 字节码的对象头占用 8 字节),这样整个数组都可以占用缓存行,也就是说四个线程都在操作一个缓存行的数据。
第二次不屏蔽倒数第三行,这样VolatileLong
包含7个long对象,对象VolatileLong
占用64字节,这样数组中的每个对象都不在同一个缓存行里。
测试结果:
屏蔽之后的
16288983000
不屏蔽
2289695890
1
2
3
4
2
3
4
# 如何避免伪共享
- 字节填充。
- JDK8 供了 一个sun.misc.Contended注解,用来解决伪共享问题。
上次更新: 2022/07/04, 17:29:55