目录
什么是缓存行对齐
验证CPU的缓存行对齐现象
原因分析

什么是缓存行对齐
高速缓存控制器是针对数据块，而不是字节进行操作的。从程序设计的角度讲，高速缓存其实就是一组称之为缓存行(cache line)的固定大小的数据块，其大小是以突发读或者突发写周期的大小

为基础的。
缓存基本上来说就是把后面的数据加载到离CPU自己进的地方，对于CPU来说，它是不会一个字节一个字节的加载的，因为这非常没有效率，一般来说都是要一块一块的加载的，在CPU的缓存技术中，这个术语叫“CacheLine”（有的中文编译成“缓存行”），一般来说，一个主流的CPU的CacheLine是64Bytes（也有的CPU用32Bytes和128Bytes），也就是16个32位的整型。也就是说，CPU从内存中捞数据上来的最小数据单位。
关于缓存行介绍详细可见：http://www.elecfans.com/d/1196867.html
验证CPU的缓存行对齐现象
由于一个缓存行是64字节，所以我们设计如下代码：
public class CacheLineTest {
    private static class TClass {
        private volatile long data = 0;
        private volatile long a, b, c, d, e, f, g;  // 测试此行加与不加时运行速度对比
    }

    private static volatile TClass[] tClasses = new TClass[2];

    static {
        tClasses[0] = new TClass();
        tClasses[1] = new TClass();
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (long i = 0; i < 1000_0000L; i++) {
                tClasses[0].data = i;
            }
        });
        Thread thread2 = new Thread(() -> {
            for (long i = 0; i < 1000_0000L; i++) {
                tClasses[1].data = i;
            }
        });
        final long start = System.nanoTime();
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println((System.nanoTime() - start) / 100_1000);
    }
}

当上面代码内部类TClass不加上标记的那一行成员变量时，运行速度如下：



当加上时，运行速度如下：


原因分析
由于缓存行是64字节，而一个long类型为8字节，当不加那一行代码时，计算的总的字节数为8+8=16字节，所以这两个变量在一个缓存行中。
于是这个缓存行中就有数据1和数据2。
当两个线程分别执行时，由于加了volatile关键字，线程1改变了缓存行中的数据1，需要去通知线程2去更新缓存行中的数据1（即使数据1线程2不需要用到），因此就降低了CPU的执行速度。
但是上面代码如果加上
private volatile long a, b, c, d, e, f, g;

这时每个TClass有8个long类型的成员变量，即8 * 8 = 64个字节，每个TClass都单独在一个缓存行中。

因此两个线程分别执行时都不需要通知对方，CPU执行速度就会增加。

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>


int main(int argc, const char *argv[])
{
    char buff[] = "this is a demo test";
    int i = 0;
    for(i=0;i<53;i++)
    {
        printf("%s", buff);
    }

    printf("1234567890");
    printf("1234567890");
    
        while(1);
        
	return 0;
}



测试结果



结论
Linux下行缓冲大小为1K。

Java多线程验证CPU缓存一致性
CPU缓存
CPU缓存层级
缓存行
缓存一致性
Java多线程验证

CPU缓存
cpu运算速度大于内存读写速度，导致cpu花费大量的时间等待从内存读取数据和写入数据。缓存的交换速度比内存快很多，它的出现缓解了这个矛盾。

CPU缓存层级
双核CPU，每个CPU有独立的缓存L1、L2，有共享的缓存L3。在缓存中没有的情况下才会去内存中读取数据。


缓存行
cpu的缓存为了性能一般是以缓存行Cache Line为单位，一次性缓存一块区域的数据。
目前最常用的Cache Line大小为64字节。

缓存一致性
对于缓存行A，如果Cpu1对其中数据a进行修改，Cpu2缓存的数据块会失效，需要重新去内存中读取一次。
缓存一致性协议：https://www.cnblogs.com/z00377750/p/9180644.html

Java多线程验证
同一个缓存行，多线程用时429ms


用数组模拟出多个缓存行的情况，用时246ms

JDK8，可以采用@Contended注解。可以不受cpu缓存行字节数的限制，可以将属性作为独立的缓存行。需要加上：JVM -XX:-RestrictContended

有待验证

缓存行（Cache Line）

CPU三级缓存
CPU直接操作内部寄存器中的数据速度比直接操作内存中的数据快百倍，为了减少这种差距，出现了缓存（Cache），现在缓存一般被封装进入CPU，分为三级缓存

L1（1ns）
L2（3ns）
L3（15ns）


x86架构64位CPU，内存缓存行大小64B（Talk is cheap, show me the code），如何在使用Java程序进行验证？

复习：CountDownLatch与Semaphore

import java.util.concurrent.CountDownLatch;


/**
 * 64位x86CPU，缓存行大小64B
 *
 *      测试一：23756 ms
 *      测试二：5688 ms
 *           性能提高4倍
 */
public class CacheLineTest1 {
    private static final int NUM = 1_000_000_000;

    private static class T{
        // private long t1,t2,t3,t4,t5,t6,t7;
        private volatile long l = 0L;
        // private long tt1,tt2,tt3,tt4,tt5,tt6,tt7;
    }

    public static T[] ts = new T[2];

    static {
        ts[0] = new T();
        ts[1] = new T();
    }

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(2);

        long satrtTime = System.currentTimeMillis();

        Thread th1 = new Thread("thread-1"){
            @Override
            public void run() {
                for(int i=0;i<NUM;i++){
                    ts[0].l = i;
                }
                latch.countDown();
            }
        };
        Thread th2 = new Thread("thread-2"){
            @Override
            public void run() {
                for(int i=0;i<NUM;i++){
                    ts[1].l = i;
                }
                latch.countDown();
            }
        };
        th1.start();
        th2.start();

        latch.await();

        long endTime = System.currentTimeMillis();
        System.out.println(endTime-satrtTime);
    }
}



解释


如果两个线程从内存中读取的数据处于同一个缓存行，那么一旦线程A修改了该缓存行中的一个变量，那么此时其他线程中使用当前变量的缓存行将会被标记为“Invalid(失效)”状态，指示线程需要再去内存中读取一遍数据；


这种协议被称为“针对缓存行CacheLine的协议”，不同硬件有该协议的不同的落地实现方式，其中一种实现是“MESI（Modify+Eclusive+Shared+Inviled）方式”，通过给缓存行添加标记的方式从硬件层面确保数据的一致性。