自从项目用了Disruptor，性能提升了2.5倍！

 一、CPU Cache

创新互联公司是创新、创意、研发型一体的综合型网站建设公司，自成立以来公司不断探索创新，始终坚持为客户提供满意周到的服务，在本地打下了良好的口碑，在过去的十多年时间我们累计服务了上千家以及全国政企客户，如成都石雕等企业单位，完善的项目管理流程，严格把控项目进度与质量监控加上过硬的技术实力获得客户的一致称赞。

存储设备往往是速度越快价格越昂贵，速度越快价格越低廉。

在计算机中，CPU 的速度远高于主存的速度，而主存的速度又远高于磁盘的速度。为了解决不同存储部件的速度不对等问题，让高速设备充分发挥性能，引入了多级缓存机制。

为了解决内存和 CPU 的速度不匹配问题，相继引入了 L1 Cache、L2 Cache、L3 Cache，数字越小，容量越小，速度越快，位置越接近 CPU。

现在的 CPU 都是由多个处理器，每个处理器由多个核心构成。一个处理器对应一个物理插槽，不同的处理器间通过 QPI 总线相连。

一个处理器间的多核共享 L3 Cache。一个核包含寄存器、L1 Cache、L2 Cache，下图是Intel Sandy Bridge CPU架构：

二、缓存行与伪共享

缓存中的数据并不是独立的进行存储的，它的最小存储单位是缓存行，缓存行的大小是2的整数幂个字节，最常见的缓存行大小是 64 字节。CPU 为了执行的高效，会在读取某个对象时，从内存上加载 64 的整数倍的长度，来补齐缓存行。

以 Java 的 long 类型为例，它是 8 个字节，假设我们存在一个长度为 8 的 long 数组 arr，那么CPU 在读取 arr[0] 时，首先查询缓存，缓存没有命中，缓存就会去内存中加载。

由于缓存的最小存储单位是缓存行，64 字节，且数组的内存地址是连续的，则将 arr[0] 到 arr[7] 加载到缓存中。后续 CPU 查询 arr[6] 时候也可以直接命中缓存。

现在假设多线程情况下，线程 A 的执行者 CPU Core-1 读取 arr[1]，首先查询缓存，缓存没有命中，缓存就会去内存中加载。

从内存中读取 arr[1] 起的连续的 64 个字节地址到缓存中，组成缓存行。由于从arr[1] 起，arr 的长度不足够 64 个字节，只够 56 个字节。假设最后 8 个字节内存地址上存储的是对象 bar，那么对象 bar 也会被一起加载到缓存行中。

现在有另一个线程 B，线程 B 的执行者 CPU Core-2 去读取对象 bar，首先查询缓存，发现命中了，因为 Core-1 在读取 arr 数组的时候也顺带着把 bar 加载到了缓存中。

这就是缓存行共享，听起来不错，但是一旦牵扯到了写入操作就不妙了。

假设 Core-1 想要更新 arr[7] 的值，根据 CPU 的 MESI 协议，那么它所属的缓存行就会被标记为失效。因为它需要告诉其他的 Core，这个 arr[7] 的值已经被更新了，缓存已经不再准确了，你必须得重新去内存拉取。但是由于缓存的最小单元是缓存行，因此只能把 arr[7] 所在的一整行给标识为失效。

此时 Core-2 就会很郁闷了，刚刚还能够从缓存中读取到对象 bar，现在再读取却被告知缓存行失效，必须得去内存重新拉取，延缓了 Core-2 的执行效率。

这就是缓存伪共享问题，两个毫无关联的线程执行，一个线程却因为另一个线程的操作，导致缓存失效。这两个线程其实就是对同一缓存行产生了竞争，降低了并发性。

三、Disruptor 缓存行填充

Disruptor 为了解决伪共享问题，使用的方法是缓存行填充。这是一种以空间换时间的策略，主要思想就是通过往对象中填充无意义的变量，来保证整个对象独占缓存行。

举个例子，以 Disruptor 中的 Sequence 为例，在 volatile long value 的前后各放置了 7 个 long 型变量，确保 value 独占一个缓存行。 

 
 
 
 
    
  
  
  
  
  1. public class Sequence extends RhsPadding {  
    2. 
  
  
  
  
  2.     private static final long VALUE_OFFSET;   
    3. 
  
  
  
  
  3.     static {  
    4. 
  
  
  
  
  4.         VALUE_OFFSET = UNSAFE.objectFieldOffset(Value.class.getDeclaredField("value"));  
    5. 
  
  
  
  
  5.         ... 
    6. 
  
  
  
  
  6.     }  
    7. 
  
  
  
  
  7.     ...  
    8. 
  
  
  
  
  8. }  
    9. 
  
  
  
  
  9. class RhsPadding extends Value {  
    10. 
  
  
  
  
  10.     protected long p9, p10, p11, p12, p13, p14, p15;  
    11. 
  
  
  
  
  11. }  
    12. 
  
  
  
  
  12. class Value extends LhsPadding {  
    13. 
  
  
  
  
  13.     protected volatile long value;  
    14. 
  
  
  
  
  14. }  
    15. 
  
  
  
  
  15. class LhsPadding {  
    16. 
  
  
  
  
  16.     protected long p1, p2, p3, p4, p5, p6, p7;  
    17. 
  
  
  
  
  17. } 
    18.

如下图所示，其中 V 就是 Value 类的 value，P 为 value 前后填充的无意义 long 型变量，U 为其它无关的变量。不论什么情况下，都能保证 V 不和其他无关的变量处于同一缓存行中，这样 V 就不会被其他无关的变量所影响。

这里的 V 也不限定为 long 类型，其实只要对象的大小大于等于8个字节，通过前后各填充 7 个 long 型变量，就一定能够保证独占缓存行。

此处以 Disruptor 的 RingBuffer 为例，最左边的 7 个 long 型变量被定义在顶级父类 RingBufferPad 中，最右边的 7 个 long 型变量被定义在 RingBuffer 的最后一行变量定义中，这样所有的需要独占的变量都被左右 long 型给包围，确保会独占缓存行。 

 
 
 
 
    
  
  
  
  
  1. public final class RingBuffer extends RingBufferFields implements Cursored, EventSequencer, EventSink {  
    2. 
  
  
  
  
  2.     public static final long INITIAL_CURSOR_VALUE = Sequence.INITIAL_VALUE;  
    3. 
  
  
  
  
  3.     protected long p1, p2, p3, p4, p5, p6, p7;  
    4. 
  
  
  
  
  4.     ...  
    5. 
  
  
  
  
  5. } 
    6. 
  
  
  
  
  6. abstract class RingBufferFields extends RingBufferPad  
    7. 
  
  
  
  
  7. {  
    8. 
  
  
  
  
  8.     ...  
    9. 
  
  
  
  
  9. }  
    10. 
  
  
  
  
  10. abstract class RingBufferPad {  
    11. 
  
  
  
  
  11.     protected long p1, p2, p3, p4, p5, p6, p7;  
    12. 
  
  
  
  
  12. } 
    13.

四、@Contended

在 JDK 1.8 中，提供了 @sun.misc.Contended 注解，使用该注解就可以让变量独占缓存行，不再需要手动填充了。另外，关注公众号Java技术栈，在后台回复：Java，可以获取我整理的 Java 1.8 系列教程，非常齐全。

注意，JVM 需要添加参数 -XX:-RestrictContended 才能开启此功能。46张PPT弄懂JVM、GC算法和性能调优，分享给你。

如果该注解被定义在了类上，表示该类的每个变量都会独占缓存行；如果被定义在了变量上，通过指定 groupName，相同的 groupName 会独占同一缓存行。 

 
 
 
 
    
  
  
  
  
  1. // 类前加上代表整个类的每个变量都会在单独的cache line中  
    2. 
  
  
  
  
  2. @sun.misc.Contended  
    3. 
  
  
  
  
  3. public class ContendedData {  
    4. 
  
  
  
  
  4.     int value;  
    5. 
  
  
  
  
  5.     long modifyTime;  
    6. 
  
  
  
  
  6.     boolean flag;  
    7. 
  
  
  
  
  7.     long createTime;  
    8. 
  
  
  
  
  8.     char key;  
    9. 
  
  
  
  
  9. }  
    10. 
  
  
  
  
  10. // 同一 groupName 在同一缓存行  
    11. 
  
  
  
  
  11. public class ContendedGroupData {  
    12. 
  
  
  
  
  12.     @sun.misc.Contended("group1")  
    13. 
  
  
  
  
  13.     int value;  
    14. 
  
  
  
  
  14.     @sun.misc.Contended("group1")  
    15. 
  
  
  
  
  15.     long modifyTime;  
    16. 
  
  
  
  
  16.     @sun.misc.Contended("group2")  
    17. 
  
  
  
  
  17.     boolean flag;  
    18. 
  
  
  
  
  18.     @sun.misc.Contended("group3")  
    19. 
  
  
  
  
  19.     long createTime;  
    20. 
  
  
  
  
  20.     @sun.misc.Contended("group3")  
    21. 
  
  
  
  
  21.     char key;  
    22. 
  
  
  
  
  22. } 
    23.

@Contended 在 JDK 源码中已经有所应用，以 Thread 类为例，为了保证多线程情况下随机数的操作不会产生伪共享，相关的变量被设置为同一 groupName。 

 
 
 
 
    
  
  
  
  
  1. public class Thread implements Runnable {  
    2. 
  
  
  
  
  2.     ...  
    3. 
  
  
  
  
  3.     // The following three initially uninitialized fields are exclusively  
    4. 
  
  
  
  
  4.     // managed by class java.util.concurrent.ThreadLocalRandom. These  
    5. 
  
  
  
  
  5.     // fields are used to build the high-performance PRNGs in the  
    6. 
  
  
  
  
  6.     // concurrent code, and we can not risk accidental false sharing.  
    7. 
  
  
  
  
  7.     // Hence, the fields are isolated with @Contended.  
    8. 
  
  
  
  
  8.     /** The current seed for a ThreadLocalRandom */  
    9. 
  
  
  
  
  9.     @sun.misc.Contended("tlr")  
    10. 
  
  
  
  
  10.     long threadLocalRandomSeed;  
    11. 
  
  
  
  
  11.     /** Probe hash value; nonzero if threadLocalRandomSeed initialized */  
    12. 
  
  
  
  
  12.     @sun.misc.Contended("tlr")  
    13. 
  
  
  
  
  13.     int threadLocalRandomProbe;  
    14. 
  
  
  
  
  14.     /** Secondary seed isolated from public ThreadLocalRandom sequence */  
    15. 
  
  
  
  
  15.     @sun.misc.Contended("tlr")  
    16. 
  
  
  
  
  16.     int threadLocalRandomSecondarySeed;  
    17. 
  
  
  
  
  17.      ...  
    18. 
  
  
  
  
  18. } 
    19.

五、速度测试

将 volatile long value 封装为对象，四线程并行，每个线程循环 1 亿次，对 value 进行更新操作，测试缓存行对速度的影响。

  •  CPU：AMD 3600 3.6 GHz
  •  Memory：16 GB

网站名称：自从项目用了Disruptor，性能提升了2.5倍！
链接URL：http://www.shufengxianlan.com/qtweb/news5/34855.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

静态网站知识

分类信息网站

网络推广公司　　 　红光高低压开关厂　　 　四川成都网站制作　　 　成都雨棚定制　　 　绵阳服务器托管　　 　物流公司网站建设方案　　 　成都网页设计　　 　手机网站建设　　 　成都网站设计　　 　艾瑞格衣柜　　 　响应式建站　　 　研学实践　　 　旅游网站建设方案　　 　网站空间　　 　吉安网站建设　　 　企业网站设计　　 　成都创新互联　　 　自贡服务器托管　　 　网站推广营销　　 　3D立体画