伪共享都不知道如何提高并发编程效率?

痛定思痛。 2022-09-01 00:03 58阅读 0赞

### 文章目录 ###

*   *  背景
     *  CPU缓存架构
     *  缓存行
     *  如何避免伪共享

## 背景 ##

在学习一些比较高性能的并发类，比如Disruptor、LongAdder之前，我们要先打一个基础，就是了解什么是伪共享

## CPU缓存架构 ##

伪共享是如何产生的呢？我们还是要从硬件级别的CPU缓存架构谈起  
CPU 是计算机的心脏，所有运算和程序最终都要由它来执行。然而CPU的执行速度又是非常快的，如果仅仅让CPU去从磁盘读取指令，那么CPU就会长时间不运行在等待磁盘加载指令，所以为了高效的让CPU工作，我们就需要在磁盘与CPU之间添加一些缓存。所以整个CPU缓存架构就变成这样了  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70]

当 CPU 执行运算的时候，它先去 L1 缓存中查找所需的数据，再去 L2，然后是 L3，最后如果这些缓存中都没有，就要去主内存拿。离CPU越远，耗时越长。所以如果在做一些很频繁的事，你要确保数据在 L1 缓存中。

> 有人可能这里可能有疑问，干嘛弄那么复杂，直接一个L1缓存不就好了，其次这里也是基于成本考虑，越靠近CPU成本越高，容量自然也就越小

## 缓存行 ##

缓存中的数据存储格式是以缓存行存储的，缓存行通常是 64 字节(也有比较旧的处理器是32字节的，这里不考虑)，而java 的long是8字节，所以一个缓存行中可以存 8 个 long 类型的变量。  
所以在程序运行的过程中，缓存每次更新都从主内存中加载连续的 64 个字节。因此，如果访问一个 long 类型的数组时，当数组中的一个值被加载到缓存中时，另外 7 个元素也会被加载到缓存中，就可以快速遍历另外的数据。但是如果数据不是连续的数组，而是链表，那么加载一个long类型可能就多加载了多余的56字节。数组看似这样优点很明显，加快了整个数组遍历速度，但是也带来了一个问题，比如刚好有8个long类型的数组arr，加载到了缓存行中，我只修改了个数组的arr\[0\]的值，其他7个值都是没有修改的，其他cpu要获取arr\[0\]的值，就必须使这个缓存行失效，就导致，arr\[0\]到arr\[7\]的数据缓存都失效了，导致在加载的时候又要重新主内存中去读取，造成了性能浪费，这就是伪共享。

总结：  
伪共享：当两个不想关联的数据比如a,b，每次要因为 a 的更新导致b缓存未命中而需要从主内存重新读取，导致效率变低，就是伪共享。

## 如何避免伪共享 ##

既然出现了这种问题就要解决，解决方式有两种

1.  自定义long类型，占64字节，填满整个缓存行
2.  使用java8提供的注解`@sun.misc.Contended`(jvm启动参数还需要添加`-XX:-RestrictContended`)

> sun.misc，这意味着一般来说是不建议我们直接使用的，所以在jdk8以上就没有这个注解了。改为@jdk.internal.vm.annotation.Contended 仅供内部使用，我们在外面使用不了。我们可以看到ConcurrentHashMap就使用了这个注解  
> ![在这里插入图片描述][c9d0a0aaa98f4135803e3418c492a105.png]

下面我们通过具体例子来看看吧

public class FalseSharingTest { 
    
        public static void main(String[] args) throws InterruptedException { 
            testPointer(new Pointer());
        }
    
        private static void testPointer(Pointer pointer) throws InterruptedException { 
            long start = System.currentTimeMillis();
            Thread t1 = new Thread(() -> { 
                for (int i = 0; i < 100000000; i++) { 
                    pointer.x++;
                }
            });
    
            Thread t2 = new Thread(() -> { 
                for (int i = 0; i < 100000000; i++) { 
                    pointer.y++;
                }
            });
    
            t1.start();
            t2.start();
            t1.join();
            t2.join();
    
            System.out.println(System.currentTimeMillis() - start);
            System.out.println(pointer.x);
            System.out.println(pointer.y);
    
        }
    }
    
    class Pointer { 
        volatile long x;
        volatile long y;
    }

执行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 1]  
注意这里要注意为什么x,y要申明为volatile，是为了两个线程保证x、y之间的可见性，让缓存失效作演示。

然后我们再看看自定义long填充满64个字节的测试

上面的代码只需要将Pointer修改一下

class Pointer { 
        volatile long x;
        long p1, p2, p3, p4, p5, p6, p7;
        volatile long y;
    }

然后我们看看执行效率  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 2]  
可以看到效率提升是很明显的

由于我本地jdk版本为11，要演示注解使用需要在javac添加下面的flag

--add-exports java.base/jdk.internal.vm.annotation=ALL-UNNAMED

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70]: /images/20220829/a28b75904fb9416280f75eb110069bb4.png
[c9d0a0aaa98f4135803e3418c492a105.png]: /images/20220829/971928833eba4efa918d320aaca6111b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 1]: /images/20220829/7310deb94b51426a90b52996bbbfd943.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 2]: /images/20220829/5789094dd3294b0da7adf53ee30c0a01.png