package top.gabin.jmm;

/**
 * CPU，硬件级别的缓存是一行读取的，一般是64位
 * <p>
 * 如果4字节的x和4字节的y同时存储在同一个缓存行中
 * <p>
 * 那么当对x做写操作的时候，需要阻塞对y的操作
 * 对y的操作也要阻塞x的操作
 * <p>
 * 所以理论上，如果能够将锁需要读取的数据独立在一个缓存行中，或者在同一个缓存行的其他数据只读，则可以提高读写效率
 */
public class CPUCacheLinePadding {

    static class DataContainer {
        private volatile long p1, p2, p3, p4, p5, p6, p7;
        public volatile long data; // 真正有用的数据
        private volatile long p8, p9, p10, p11, p12, p13, p14;

    }

    static class DataContainer1 {
        public volatile long data;

    }

    public static void main(String[] args) throws InterruptedException {
        // 伪缓存问题

        // 1、使用了补齐的方式，使得真正有意义的数据被保存在一个缓存行中，不和其他会被写的数据一起
        long start = System.currentTimeMillis();
        test1();
        System.out.println("补齐，解决伪共享问题:" + (System.currentTimeMillis() - start));
        // 2、普通的方式
        start = System.currentTimeMillis();
        test2();
        System.out.println("一般场景:" + (System.currentTimeMillis() - start));

    }

    private static void test1() throws InterruptedException {
        DataContainer[] containers = new DataContainer[2];
        containers[0] = new DataContainer();
        containers[1] = new DataContainer();

        Thread t1 = new Thread(() -> {
            for (int j = 0; j < 100_000_000; j++) {
                containers[0].data = j;
            }
        });
        t1.start();
        Thread t2 = new Thread(() -> {
            for (int j = 0; j < 100_000_000; j++) {
                containers[1].data = j;
            }
        });
        t2.start();
        t1.join();
        t2.join();

    }

    private static void test2() throws InterruptedException {
        DataContainer1[] containers = new DataContainer1[2];
        containers[0] = new DataContainer1();
        containers[1] = new DataContainer1();
        Thread t1 = new Thread(() -> {
            for (int j = 0; j < 100_000_000; j++) {
                containers[0].data = j;
            }
        });
        t1.start();
        Thread t2 = new Thread(() -> {
            for (int j = 0; j < 100_000_000; j++) {
                containers[1].data = j;
            }
        });
        t2.start();
        t1.join();
        t2.join();
    }

}

package top.gabin.jmm;

/**
 * CPU重排序的问题
 * <p>
 * 如果指令1和指令2之间没有依赖关系，那么在CPU执行的时候，可能先执行指令2，再去执行指令1
 * <p>
 * 比如说一般一个方法的JVM汇编指令第一个是去加载this对象，从内存中读取的速度远低于CPU 寄存器执行的时间，这时候可能
 * 第二条指令只需要执行1ms，那么有可能，CPU会选择先执行第二条指令
 * <p>
 * 这个在多线程中可能存在一个执行顺序的问题，
 * 比如
 * <p>
 * 线程1
 * b=1
 * x=a
 * <p>
 * 线程2
 * a=1
 * y=b
 * <p>
 * 看上去线程1的两行代码和线程2的两行代码没有直接关联，所以存在CPU指令乱序的可能性，
 */
public class DisOrder {

    private static int x, y, a, b;

    public static void main(String[] args) throws InterruptedException {
        for (; ; ) {
            x = 0;
            y = 0;
            a = 0;
            b = 0;
            Thread t1 = new Thread(() -> {
                // 不加这行的话，如果CPU执行速度很快，说不准，压根就测不出来，这个问题可以类比到某些手机端IOS根本出现不了问题，但是ANDROID就会
                // 以前大概遇到过一次是IOS渲染比较快，所以就不会出现问题，ANDROID渲染执行比较慢，出现了执行顺序的问题
                shortWait(100000);
                // 这里必须是很单纯的代码调用，不能是非原子性的，比如long，64位，不是原子性操作
                a = 1;
                x = b;
            });
            Thread t2 = new Thread(() -> {
                // 这里必须是很单纯的代码调用，不能是非原子性的，比如long，64位，不是原子性操作
                b = 1;
                y = a;
            });
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            if (x == 0 && y == 0) {
                System.out.println("存在CPU指令重排，x==y==0");
                break;
            }
        }
    }

    public static void shortWait(long interval) {
        long start = System.nanoTime();
        long end;
        do {
            end = System.nanoTime();
        } while (start + interval >= end);
    }

}

package top.gabin.jmm;

/**
 * 存在一个WCBuffer的缓存，四个槽
 *
 * 这个缓存比CPU的L1缓存更快
 *
 * 如果能触发合并写，写的速度将会更快
 */
public class WriteCombine {

    private static final int ITERATIONS = Integer.MAX_VALUE;
    private static final int ITEMS = 1 << 24;
    private static final int MASK = ITEMS - 1;

    private static final byte[] arrayA = new byte[ITEMS];
    private static final byte[] arrayB = new byte[ITEMS];
    private static final byte[] arrayC = new byte[ITEMS];
    private static final byte[] arrayD = new byte[ITEMS];
    private static final byte[] arrayE = new byte[ITEMS];
    private static final byte[] arrayF = new byte[ITEMS];


    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            System.out.println(i + " SingleLoop duration (ns) = " + runCaseOne());
            System.out.println(i + " SplitLoop  duration (ns) = " + runCaseTwo());
        }
    }

    public static long runCaseOne() {
        long start = System.nanoTime();
        int i = ITERATIONS;

        while (--i != 0) {
            int slot = i & MASK;
            byte b = (byte) i;
            arrayA[slot] = b;
            arrayB[slot] = b;
            arrayC[slot] = b;
            arrayD[slot] = b;
            arrayE[slot] = b;
            arrayF[slot] = b;
        }
        return System.nanoTime() - start;
    }

    public static long runCaseTwo() {
        long start = System.nanoTime();
        int i = ITERATIONS;
        while (--i != 0) {
            int slot = i & MASK;
            byte b = (byte) i;
            arrayA[slot] = b;
            arrayB[slot] = b;
            arrayC[slot] = b;
        }
        i = ITERATIONS;
        while (--i != 0) {
            int slot = i & MASK;
            byte b = (byte) i;
            arrayD[slot] = b;
            arrayE[slot] = b;
            arrayF[slot] = b;
        }
        return System.nanoTime() - start;
    }

}