JAVA多线程-编发编程三大特性之可见性

可见性
volatile 修饰变量

package com.juc.c_001_01_Visibility;

import com.util.SleepHelper;

import java.io.IOException;

public class T01_HelloVolatile {//volatile 保持可见性
    private static volatile boolean running = true;

    private static void m() {
        System.out.println("m start");
        while (running) {//running变量不被volatile修饰 在线程启动运行的时候是从主内存读取m到线程本地，
                        // 后面主线程对running修改不会同步到线程中的running变量 该线程看不到
            //volatile修饰的变量每次读的时候都会从主内存读一遍 变量有改动 下次线程读取从主存读取就会获取到最新的变量 主存修改会同步到线程
            //System.out.println("hello");//放开该注释 即使变量不被volatile修饰 主线程修改后也会被同步到这个线程，
                                       // 因为System.out.println有个synchronized关键字 synchronized也可保持可见性 某些语句执行 触发本地缓存和线程缓存进行数据刷新和同步
        }
        System.out.println("m end!");
    }

    public static void main(String[] args) throws IOException {

        new Thread(T01_HelloVolatile::m, "t1").start();

        SleepHelper.sleepSeconds(1);

        running = false;

        System.in.read();
    }
}

volatile 引用类型

package com.mashibing.juc.c_001_01_Visibility;

import com.mashibing.util.SleepHelper;

public class T02_VolatileReference {

    private static class A {
        boolean running = true;

        void m() {
            System.out.println("m start");
            while (running) {
            }
            System.out.println("m end!");
        }
    }

    private volatile static A a = new A();

    public static void main(String[] args) {
        new Thread(a::m, "t1").start();
        SleepHelper.sleepSeconds(1);
        a.running = false;//volatile 引用类型（包括数组）只能保证引用本身的可见性，不能保证内部字段的可见性
        // ,如果想保证可见性 就要把对象内的属性加上volatile修饰
    }


}

存储器的层析结构

寄存器需要数据，先去L1-> L2-> L3, L3没有就去主存 ;读数据先往L3存， 然后L2 ，L1 。

可见性指的是在多核CPU 中，主存的数据，在不同核的三级缓存中主存改变了，每个核的其他缓存也可见。

按块读取
程序局部性原理，可以提高效率，充分发挥总线 CPU针脚等一次性读取更多数据的能力。
空间局部性原理:读到一个数据，相邻的数据也会一次性读到缓存 一次读取一整块数据一整块就是缓存行cach line 一个缓存行大小是64字节；
时间局部性原理: 读取指令的时候把很多指令的数据一次性读取到缓存。
访问一个数据会把xy全部缓存进来 既然xy在cpu1和CPU2 ，采用缓存一致性协议保证CPU1和CPU2的xy保持一致性 ，当x修改 缓存行通知cpu把数据从内存刷新到缓存，正是由于这个机制多线程修改的东西在同一行的时候会互相干扰。

package com.mashibing.juc.c_001_02_FalseSharing;

import java.util.concurrent.CountDownLatch;

public class T01_CacheLinePadding {
    public static long COUNT = 10_0000_0000L;

    private static class T {
        //private long p1, p2, p3, p4, p5, p6, p7;
        public long x = 0L; //8bytes 8个long就沾满一个缓存行大小
        //private long p9, p10, p11, p12, p13, p14, p15;
    }

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

    static {
        arr[0] = new T();
        arr[1] = new T();
        //两个位于同一个缓存行 读取数据的时候会把那一个数据所在的缓存行全部读取进来
    }

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

        Thread t1 = new Thread(() -> {
            for (long i = 0; i < COUNT; i++) {
                arr[0].x = i;
            }

            latch.countDown();
        });

        Thread t2 = new Thread(() -> {
            for (long i = 0; i < COUNT; i++) {
                arr[1].x = i;
            }

            latch.countDown();
        });

        final long start = System.nanoTime();
        t1.start();
        t2.start();
        latch.await();
        System.out.println((System.nanoTime() - start) / 100_0000);
    }
}

放开class T的两行注释，会发现运行时间会更快。因为放开注释之前，两个对象很大可能在同一个缓存行，因为缓存一致性协议，两个对象任何一个的数据发生变化，缓存行都会同步这个缓存行的数据去主存拿最新的，即使自己的数据没有变，因为在同一个缓存行，旁边的数据变了，这个线程所在的缓存也要去更新数据，所以会慢。通过前后填充7个long，一共8个long，64字节，每一个对象占据一个缓存行，所以减少互相之间的干扰，会变得快。

Disruptor单机性能最高的mq 环形缓冲区


采用填充的形式，沾满缓存行，提高性能。

@Contended
保证x位于单独一行中 不会和别的位于一个缓冲行
运行这个小程序的时候，需要加参数：-XX:-RestrictContended

package com.juc.c_001_02_FalseSharing;


import sun.misc.Contended;
//注意：运行这个小程序的时候，需要加参数：-XX:-RestrictContended
import java.util.concurrent.CountDownLatch;

public class T05_Contended {
    public static long COUNT = 10_0000_0000L;

    //@Contended  //只有1.8起作用 , 保证x位于单独一行中 不会和别的位于一个缓冲行
    private static class T {
        public long x = 0L;
    }

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

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

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

        Thread t1 = new Thread(() -> {
            for (long i = 0; i < COUNT; i++) {
                arr[0].x = i;
            }

            latch.countDown();
        });

        Thread t2 = new Thread(() -> {
            for (long i = 0; i < COUNT; i++) {
                arr[1].x = i;
            }

            latch.countDown();
        });

        final long start = System.nanoTime();
        t1.start();
        t2.start();
        latch.await();
        System.out.println((System.nanoTime() - start) / 100_0000);
    }
}

MESI Cache一致性协议 缓存一致性协议的一种

缓存行的四种状态
主动性的进行数据更新，多个CPU都有的数据，一个改变了，其他的也会改变，下次使用就会去主存读取。

缓存行：
缓存行越大，局部性空间效率越高，但读取时间慢
缓存行越小，局部性空间效率越低，但读取时间快
取一个折中值，目前多用：
64字节