伪共享

从字面意思，我一开始理解的有点迷糊，一开始以为在内存中的变量是不可靠的呢，但是不是！它带来的影响是，会造成多线程操作同一个缓存行的变量性能下降，因为同一个缓存行的修改，只能能同时被一个线程修改，这样就失去了多线程的意义

伪共享的非标准定义为：缓存系统中是以缓存行（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;     //屏蔽此行
        }
    }

代码原理：初始化容量为四的数组，和四个线程，一个线程会去不断地更新的数组中的值。循环10次 测试分两次： 第一次屏蔽倒数第三行，这样VolatileLong只有一个long对象，VolatileLong占用 16个字节(类对象的 字节码的对象头占用 8 字节)，这样整个数组都可以占用缓存行，也就是说四个线程都在操作一个缓存行的数据。 第二次不屏蔽倒数第三行，这样VolatileLong包含7个long对象，对象VolatileLong占用64字节，这样数组中的每个对象都不在同一个缓存行里。 测试结果：

屏蔽之后的
16288983000
不屏蔽
2289695890

如何避免伪共享

1. 字节填充。
2. JDK8 供了 一个sun.misc.Contended注解，用来解决伪共享问题。

参考： 伪共享（false sharing），并发编程无声的性能杀手 (opens new window)