关于后端:并发刺客False-Sharing并发程序的隐藏杀手

并发刺客（False Sharing）——并发程序的暗藏杀手

前言

前段时间在各种社交平台“雪糕刺客”这个词比拟火，简略的来说就是雪糕的价格十分高！其实在并发程序当中也有一个刺客，如果在写并发程序的时候不留神不小心，这个刺客很可能会连累咱们的并发程序，让咱们并发程序执行的效率变低，让并发程序付出很大的代价，这和“雪糕刺客”当中的“刺客”的含意是统一的。这个并发程序当中的刺客就是——假共享（False Sharing）。

假共享（False Sharing）

缓存行

当CPU从更慢级别的缓存读取数据的时候（三级Cache会从内存当中读取数据，二级缓存会从三级缓存当中读取数据，一级缓存会从二级缓存当中读取数据，缓存级别越低执行速度越快），CPU并不是一个字节一个字节的读取的，而是一次会读取一块数据，而后将这个数据缓存到CPU当中，而这一块数据就叫做缓存行。有一种缓存行的大小就是64字节，那么咱们为什么会做这种优化呢？这是因为局部性原理，所谓局部性原理简略说来就是，过后应用一个数据的时候，它左近的数据在将来的一段时间你也很可能用到，比如说咱们遍历数组，咱们通常从前往后进行遍历，比方咱们数组当中的数据大小是8个字节，如果咱们的缓存行是64个字节的话，那么一个缓存行就能够缓存8个数据，那么咱们在遍历第一个数据的时候将这8个数据加载进入缓存行，那么咱们在遍历将来7个数据的时候都不须要再从内存当中拿数据，间接从缓存当中拿就行，这就能够节约程序执行的工夫。

假共享

当两个线程在CPU上两个不同的外围上执行代码的时候，如果这两个线程应用了同一个缓存行C，而且对这个缓存行当中两个不同的变量进行写操作，比方线程A对变量a进行写操作，线程B对变量b进行写操作。而因为缓存一致性（Cache coherence）协定的存在，如果其中A线程对缓存行C中变量a进行了写操作的话，为了保障各个CPU外围的数据统一（也就是说两个CPU外围看到了a的值是一样的，因为a的值曾经发生变化了，须要让另外的CPU外围晓得，不然另外的CPU外围应用的就是旧的值，那么程序后果就不对了），其余外围的这个缓存行就会生效，如果他还想应用这个缓存行的话就须要从新三级Cache加载，如果数据不存在三级Cache当中的话，就会从内存当中加载，而这个从新加载的过程就会很连累程序的执行效率，而事实上线程A写的是变量a，线程B写的是变量b，他们并没有真正的有共享的数据，只是他们须要的数据在同一个缓存行当中，因而称这种景象叫做假共享（False Sharing）。

下面咱们谈到了，当缓存行生效的时候会从三级Cache或者内存当中加载，而多个不同的CPU外围是共享三级Cache的（上图当中曾经显示进去了），其中一个CPU外围更新了数据，会把数据刷新到三级Cache或者内存当中，因而这个时候其余的CPU外围去加载数据的时候就是新值了。

下面谈到的对于CPU的缓存一致性（Cache coherence）的内容还是比拟少的，如果你想深刻理解缓存一致性（Cache coherence）和缓存一致性协定能够认真去看这篇文章。

咱们再来举一个更加具体的例子：

假如在内存当中，变量a和变量b都占四个字节，而且他们的内存地址是间断且相邻的，当初有两个线程A和B，线程A要一直的对变量a进行+1操作，线程B须要一直的对变量进行+1操作，当初这个两个数据所在的缓存行曾经被缓存到三级缓存了。

线程A从三级缓存当中将数据加载到二级缓存和一级缓存而后在CPU- Core0当中执行代码，线程B从三级缓存将数据加载到二级缓存和一级缓存而后在CPU- Core1当中执行代码。
线程A一直的执行a += 1，因为线程B缓存的缓存行当中蕴含数据a，线程A在批改a的值之后，就会在总线上发送音讯，让其余处理器当中含有变量a的缓存行生效，在处理器将缓存行生效之后，就会在总线上发送音讯，示意缓存行曾经生效，线程A所在的CPU- Core0收到音讯之后将更新后的数据刷新到三级Cache。
这个时候线程B所在的CPU-Core1当中含有a的缓存行曾经生效，因为变量b和变量a在同一个缓存行，当初线程B想对变量b进行加一操作，然而在一级和二级缓存当中曾经没有了，它须要三级缓存当中加载这个缓存行，如果三级缓存当中没有就须要去内存当中加载。
仔细分析下面的过程你就会发现线程B并没有对变量a有什么操作，然而它须要的缓存行就生效了，尽管和线程B共享须要同一个内容的缓存行，然而他们之间并没有真正共享数据，所以这种景象叫做假共享。

Java代码复现假共享

复现假共享

上面是两个线程一直对两个变量执行++操作的代码：

class Data {  public volatile long a;  public volatile long b;}public class FalseSharing {  public static void main(String[] args) throws InterruptedException {    Data data = new Data();    long start = System.currentTimeMillis();    Thread A = new Thread(() -> {      for (int i = 0;  i < 500_000_000; i++) {        data.a += 1;      }    }, "A");    Thread B = new Thread(() -> {      for (int i = 0;  i < 500_000_000; i++) {        data.b += 1;      }    }, "B");    A.start();    B.start();    A.join();    B.join();    long end = System.currentTimeMillis();    System.out.println("破费工夫为：" + (end - start));    System.out.println(data.a);    System.out.println(data.b);  }}

下面的代码比较简单，这里就不进行阐明了，下面的代码在我的笔记本上的执行工夫大概是17秒。

下面的代码变量a和变量b在内存当中的地位是相邻的，他们在被CPU加载之后会在同一个缓存行当中，因而会存在假共享的问题，程序的执行工夫会变长。

上面的代码是优化过后的代码，在变量a后面和前面别离退出56个字节的数据，再加上a的8个字节（long类型是8个字节），这样a前后加上a的数据有64个字节，而当初支流的缓存行是64个字节，够一个缓存行的大小，因为数据a和数据b就不会在同一个缓存行当中，因而就不会存在假共享的问题了。而上面的代码在我笔记本当中执行的工夫大概为5秒。这就足以看出假共享会对程序的执行带来多大影响了。

class Data {  public volatile long a1, a2, a3, a4, a5, a6, a7;  public volatile long a;  public volatile long b1, b2, b3, b4, b5, b6, b7;  public volatile long b;}public class FalseSharing {  public static void main(String[] args) throws InterruptedException {    Data data = new Data();    long start = System.currentTimeMillis();    Thread A = new Thread(() -> {      for (int i = 0;  i < 500_000_000; i++) {        data.a += 1;      }    }, "A");    Thread B = new Thread(() -> {      for (int i = 0;  i < 500_000_000; i++) {        data.b += 1;      }    }, "B");    A.start();    B.start();    A.join();    B.join();    long end = System.currentTimeMillis();    System.out.println("破费工夫为：" + (end - start));    System.out.println(data.a);    System.out.println(data.b);  }}

JDK解决假共享

为了解决假共享的问题，JDK为咱们提供了一个注解@Contened解决假共享的问题。

import sun.misc.Contended;class Data {//  public volatile long a1, a2, a3, a4, a5, a6, a7;  @Contended  public volatile long a;//  public volatile long b1, b2, b3, b4, b5, b6, b7;  @Contended  public volatile long b;}public class FalseSharing {  public static void main(String[] args) throws InterruptedException {    Data data = new Data();    long start = System.currentTimeMillis();    Thread A = new Thread(() -> {      for (long i = 0;  i < 500_000_000; i++) {        data.a += 1;      }    }, "A");    Thread B = new Thread(() -> {      for (long i = 0;  i < 500_000_000; i++) {        data.b += 1;      }    }, "B");    A.start();    B.start();    A.join();    B.join();    long end = System.currentTimeMillis();    System.out.println("破费工夫为：" + (end - start));    System.out.println(data.a);    System.out.println(data.b);  }}

下面代码的执行工夫也是5秒左右，和之前咱们本人在变量的左右两边插入变量的成果是一样的，然而JDK提供的这个接口和咱们本人实现的还是有所区别的。（留神：下面的代码是在JDK1.8下执行的，如果要想@Contended注解失效，你还须要在JVM参数上退出-XX:-RestrictContended，这样下面的代码能力失效否则是不可能失效的）

在咱们本人解决假共享的代码当中，是在变量a的左右两边退出56个字节的其余变量，让他和变量b不在同一个缓存行当中。
在JDK给咱们提供的注解@Contended，是在被加注解的字段的左边退出肯定数量的空字节，默认退出128空字节，那么变量a和变量b之间的内存地址大一点，最终不在同一个缓存行当中。这个字节数量能够应用JVM参数-XX:ContendedPaddingWidth=64，进行管制，比方这个是64个字节。
除此之外@Contended注解还可能将变量进行分组：

class Data {  @Contended("a")  public volatile long a;    @Contended("bc")  public volatile long b;  @Contended("bc")  public volatile long c;}

在解析注解的时候会让同一组的变量在内存当中的地位相邻，不同的组之间会有肯定数量的空字节，配置形式还是跟下面一样，默认每组之间空字节的数量为128。

比方下面的变量在内存当中的逻辑布局具体布局如下：

 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)      8     4        (object header)                           20 0a 06 00 (00100000 00001010 00000110 00000000) (395808)     12   132        (alignment/padding gap)                      144     8   long Data.a                                    0    152   128        (alignment/padding gap)                      280     8   long Data.b                                    0    288     8   long Data.c                                    0    296   128        (loss due to the next object alignment)Instance size: 424 bytesSpace losses: 260 bytes internal + 128 bytes external = 388 bytes total

下面的内容是通过上面代码打印的，你只有在pom文件当中引入包jol即可：

import org.openjdk.jol.info.ClassLayout;import sun.misc.Contended;class Data {  @Contended("a")  public volatile long a;    @Contended("bc")  public volatile long b;  @Contended("bc")  public volatile long c;}public class FalseSharing {  public static void main(String[] args) throws InterruptedException {    Data data = new Data();    System.out.println(ClassLayout.parseInstance(data).toPrintable());  }}

从更低层次C语言看假共享

后面咱们是应用Java语言去验证假共享，在本大节当中咱们通过一个C语言的多线程程序（应用pthread）去验证假共享。（上面的代码在类Unix零碎都能够执行）

#include <stdio.h>#include <pthread.h>#include <time.h>#define CHOOSE // 这里定义了 CHOOSE 如果不想定义CHOOSE 则将这一行正文掉即可// 定义一个全局变量int data[1000];void* add(void* flag) {  // 这个函数的作用就是一直的往 data 当中的某个数据进行加一操作  int idx = *((int *)flag);  for (long i = 0; i < 10000000000; ++i) {    data[idx]++;  }}int main() {  pthread_t a, b;#ifdef CHOOSE // 如果定义了 CHOOSE 则执行上面的代码 让两个线程操作的变量隔得远一点 让他们不在同一个缓存行当中  int flag_a = 0;  int flag_b = 100;  printf("远离\n");#else // 如果没有定义 让他们隔得近一点 也就是说让他们在同一个缓存行当中  int flag_a = 0;  int flag_b = 1;  printf("邻近\n");#endif  pthread_create(&a, NULL, add, &flag_a); // 创立线程a 执行函数 add 传递参数 flag_a 并且启动  pthread_create(&b, NULL, add, &flag_b); // 创立线程b 执行函数 add 传递参数 flag_b 并且启动  long start = time(NULL);  pthread_join(a, NULL); // 主线程期待线程a执行实现  pthread_join(b, NULL); // 主线程期待线程b执行实现  long end = time(NULL);  printf("data[0] = %d\t data[1] = %d\n", data[0], data[1]);  printf("cost time = %ld\n", (end - start));  return 0;}

下面代码的输入后果如下图所示：

咱们首先来解释一下下面time命令的输入：

readl：这个示意真实世界当中的墙钟工夫，就是示意这个程序执行所破费的工夫，这个秒单位和咱们平时说的秒是一样的。
user：这个示意程序在用户态执行的CPU工夫，CPU工夫和实在工夫是不一样的，这里须要留神辨别，这里的秒和咱们平时的秒是不一样的。
sys：这个示意程序在内核态执行所破费的CPU工夫。

从下面程序的输入后果咱们能够很显著的看进去当操作的两个整型变量相隔距离远的时候，也就是不在同一个缓存行的时候，程序执行的速度是比数据隔得近在同一个缓存行的时候快得多，这也从侧面显示了假共享很大水平的升高了程序执行的效率。

总结

在本篇文章当中次要探讨了以下内容：

当多个线程操作同一个缓存行当中的多个不同的变量时，尽管他们事实上没有对数据进行共享，然而他们对同一个缓存行当中的数据进行批改，而因为缓存一致性协定的存在会导致程序执行的效率升高，这种景象叫做假共享。
在Java程序当中咱们如果想让多个变量不在同一个缓存行当中的话，咱们能够在变量的旁边通过减少其余变量的形式让多个不同的变量不在同一个缓存行。
JDK也为咱们提供了Contended注解能够在字段的前面通过减少空字节的形式让多个数据不在同一个缓存行，而且你须要在JVM参数当中退出-XX:-RestrictContended，同时你能够通过JVM参数-XX:ContendedPaddingWidth=64调整空字节的数目。JDK8之后注解Contended在JDK当中的地位有所变动，大家能够查问一下。
咱们也是用了C语言的API去测试了假共享，事实上在Java虚拟机当中底层的线程也是通过调用pthread_create进行创立的。

更多精彩内容合集可拜访我的项目：https://github.com/Chang-LeHu...

关注公众号：一无是处的钻研僧，理解更多计算机（Java、Python、计算机系统根底、算法与数据结构）常识。