一、JMM

JMM 即 Java Memory Model，它定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、CPU 指令优化等。
JMM 体现在以下几个方面

• 原子性 - 保证指令不会受到线程上下文切换的影响
• 可见性 - 保证指令不会受 cpu 缓存的影响
• 有序性 - 保证指令不会受 cpu 指令并行优化的影响

主存对应堆内存，工作内存对应栈内存，线程需要从主存读数据，然后在工作内存中计算，最后写回主存。

二、可见性

@Slf4j
public class TestVisible {
    static boolean runFlag = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (runFlag){

            }
            log.debug("停止循环了");
        });
        t.start();

        Thread.sleep(1000);
        log.debug("停止t1");
        runFlag = false;
    }
}

17:28:19.008 [main] DEBUG juc.visibility.TestVisible - 停止t1

1.初始状态， t 线程刚开始从主内存读取了 run 的值到工作内存

image.png

2.因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中，减少对主存中 run 的访问，提高效率

image.png

3.1 秒之后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存中的高速缓存中读取这个变量的值，结果永远是旧值

image.png

解决方式一：volatile(推荐)
volatile：它可以用来修饰成员变量和静态成员变量，可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存。

@Slf4j
public class TestVisible {
    static volatile boolean runFlag = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (runFlag){

            }
            log.debug("停止循环了");
        });
        t.start();

        Thread.sleep(1000);
        log.debug("停止t1");
        runFlag = false;
    }
}

18:33:39.386 [main] DEBUG juc.visibility.TestVisible - 停止t1
18:33:39.389 [Thread-0] DEBUG juc.visibility.TestVisible - 停止循环了

解决方式二：synchronized

@Slf4j
public class TestVisible1 {
    static boolean runFlag = true;
    final static Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (true){
                synchronized (lock){
                    if(!runFlag){
                        break;
                    }
                }
            }
            log.debug("停止循环了");
        });
        t.start();

        Thread.sleep(1000);
        log.debug("停止t1");
        synchronized (lock){
            runFlag = false;
        }
    }
}

线程进入synchronized代码前，会获得锁，清空工作内存，从主内存拷贝共享变量最新的值到工作内存成为副本，执行代码，将修改后的副本值刷新回主内存中，释放锁。

可见性 vs 原子性

可见性保证的是在多个线程之间，一个线程对 volatile 变量的修改对另一个线程可见， 但不能保证原子性，仅用在一个写线程，多个读线程的情况：
上例从字节码理解是这样的：

getstatic run // 线程 t 获取 run true
getstatic run // 线程 t 获取 run true
getstatic run // 线程 t 获取 run true
getstatic run // 线程 t 获取 run true
putstatic run // 线程 main 修改 run 为 false， 仅此一次
getstatic run // 线程 t 获取 run false

两个线程：一个 i++ 一个 i-- ，只能保证看到最新值，不能解决指令交错的原子性问题：

// 假设i的初始值为0
getstatic i // 线程2-获取静态变量i的值 线程内i=0

getstatic i // 线程1-获取静态变量i的值 线程内i=0
iconst_1 // 线程1-准备常量1
iadd // 线程1-自增 线程内i=1
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1

iconst_1 // 线程2-准备常量1
isub // 线程2-自减 线程内i=-1
putstatic i // 线程2-将修改后的值存入静态变量i 静态变量i=-1

synchronized 语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性。但缺点是synchronized 是属于重量级操作，性能相对更低

三、volatile应用

使用volatile改进两阶段终止：

@Slf4j
public class TestVolatile {

    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTerminate twoPhaseTerminate = new TwoPhaseTerminate();
        twoPhaseTerminate.start();
        Thread.sleep(4000);
        twoPhaseTerminate.stop();
    }
}

@Slf4j
class TwoPhaseTerminate {

    private Thread monitorThread;

    private volatile boolean stopFlag = false;

    /**
     * 启动线程
     */
    public void start() {
        monitorThread = new Thread(() -> {
            while (true) {
                // 是否被打断
                if (stopFlag) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("执行监控记录");
                } catch (InterruptedException e) {
                    //不需要考虑打断标记，因为使用的是stopFlag来控制的
                    e.printStackTrace();
                }
            }
        }, "monitor");
        monitorThread.start();
    }

    /**
     * 停止线程
     */
    public void stop() {
        stopFlag = true;
        //防止线程刚好在执行sleep的过程中被停止，用interrupt来终止sleep
        monitorThread.interrupt();
    }
}

19:31:36.199 [monitor] DEBUG juc.visibility.TwoPhaseTerminate - 执行监控记录
19:31:37.205 [monitor] DEBUG juc.visibility.TwoPhaseTerminate - 执行监控记录
19:31:38.206 [monitor] DEBUG juc.visibility.TwoPhaseTerminate - 执行监控记录
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at juc.visibility.TwoPhaseTerminate.lambda$start$0(TestVolatile.java:43)
    at java.lang.Thread.run(Thread.java:748)
19:31:39.195 [monitor] DEBUG juc.visibility.TwoPhaseTerminate - 料理后事

四、同步模式之Balking

Balking（犹豫）模式用在一个线程发现另一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做了，直接结束返回。🙃🙃🙃
demo1:

@Slf4j
public class TestVolatile {

    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTerminate twoPhaseTerminate = new TwoPhaseTerminate();
        twoPhaseTerminate.start();
        twoPhaseTerminate.start();
        twoPhaseTerminate.start();
        Thread.sleep(4000);
        twoPhaseTerminate.stop();
    }
}

@Slf4j
class TwoPhaseTerminate {

    private Thread monitorThread;

    private volatile boolean stopFlag = false;

    /**
     * 用一个标记位来标记只需要执行一遍的代码不重复执行
     */
    private boolean startFlag = false;

    /**
     * 启动线程
     */
    public void start() {
        synchronized (this) {
            if (startFlag) {
                return;
            }
            startFlag = true;
        }
        monitorThread = new Thread(() -> {
            while (true) {
                // 是否被打断
                if (stopFlag) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("执行监控记录");
                } catch (InterruptedException e) {
                    //不需要考虑打断标记，因为使用的是stopFlag来控制的
                    e.printStackTrace();
                }
            }
        }, "monitor");
        monitorThread.start();
    }

    /**
     * 停止线程
     */
    public void stop() {
        stopFlag = true;
        //防止线程刚好在执行sleep的过程中被停止，用interrupt来终止sleep
        monitorThread.interrupt();
    }
}

19:54:17.437 [monitor] DEBUG juc.visibility.TwoPhaseTerminate - 执行监控记录
19:54:18.441 [monitor] DEBUG juc.visibility.TwoPhaseTerminate - 执行监控记录
19:54:19.443 [monitor] DEBUG juc.visibility.TwoPhaseTerminate - 执行监控记录
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at juc.visibility.TwoPhaseTerminate.lambda$start$0(TestVolatile.java:55)
    at java.lang.Thread.run(Thread.java:748)
19:54:20.432 [monitor] DEBUG juc.visibility.TwoPhaseTerminate - 料理后事

demo2:

public class Singleton {

    private static Singleton INSTANCE = null;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (INSTANCE != null) {
            return INSTANCE;
        }
        return new Singleton();
    }
}

五、有序性

1.指令重排序优化

现代处理器会设计为一个时钟周期完成一条执行时间最长的 CPU 指令：
指令可以再划分成一个个更小的阶段，例如，每条指令都可以分为：
取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回 这 5 个阶段。

在不改变程序结果的前提下，这些指令的各个阶段可以通过重排序和组合来实现指令级并行，这一技术在 80's 中叶到 90's 中叶占据了计算架构的重要地位。

指令重排的前提是，重排指令不能影响结果，例如

// 可以重排的例子
int a = 10; // 指令1
int b = 20; // 指令2
System.out.println( a + b );
// 不能重排的例子
int a = 10; // 指令1
int b = a - 5; // 指令2

2.支持流水线的处理器

现代 CPU 支持多级指令流水线，例如支持同时执行 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回 的处理器，就可以称之为五级指令流水线。这时 CPU 可以在一个时钟周期内，同时运行五条指令的不同阶段（相当于一条执行时间最长的复杂指令），IPC = 1，本质上，流水线技术并不能缩短单条指令的执行时间，但它变相地提高了指令地吞吐率。

3.内存屏障

Memory Barrier（Memory Fence）

可见性：

• 写屏障（sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中
• 读屏障（lfence）保证在该屏障之后，对共享变量的读取，加载的是主存中最新数据

有序性:

• 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
• 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

六、volatile 原理

volatile 的底层实现原理是内存屏障：Memory Barrier（Memory Fence）

• 对 volatile 变量的写指令后会加入写屏障
• 对 volatile 变量的读指令前会加入读屏障

1.保证可见性

写屏障（sfence）：保证在该屏障之前的，对共享变量的改动（不只是volatile修饰的），都同步到主存当中：

private volatile boolean ready = false;
public void test(Result r) {
  //num是普通变量，也会被同步到主存
  num = 2; 
   // ready 是 volatile ，赋值带写屏障
  ready = true;
  // 写屏障
}

读屏障（lfence）：保证在该屏障之后，对共享变量的读取，加载的是主存中最新数据：

private volatile boolean ready = false;
public void test(Result r) {
  // 读屏障
  // ready 是 volatile 读取值，带读屏障
  if(ready) {
    r.r1 = num + num;
  } else {
    r.r1 = 1;
  }
}

image.png

写屏障之前的都写进主存，读屏障之后的都从主存读。

2.保证有序性

写屏障：确保指令重排序时，不会将写屏障之前的代码排在写屏障之后

public void test(Result r) {
  num = 2;
  // ready 是 volatile， 赋值带写屏障
  ready = true; 
  // 写屏障
}

读屏障：确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

public void test(Result r) {
  // 读屏障
  // ready 是 volatile， 读取值带读屏障
  if(ready) {
    r.r1 = num + num;
  } else {
    r.r1 = 1;
  }
}

3.保证不了原子性

不能解决指令交错：

• 写屏障仅仅是保证之后的读能够读到最新的结果，但不能保证读跑到它前面去
• 有序性的保证也只是保证了本线程内相关代码不被重排序

七、double-checked lock

public final class Singleton {
    private Singleton() { }
    private static Singleton INSTANCE = null;
    public static Singleton getInstance() {
        if(INSTANCE == null) {
            synchronized(Singleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

以上单例模式存在的问题：
getInstance 方法对应的字节码为

         0: getstatic     #2                  // Field INSTANCE:Ljuc/visibility/DCLSingleton;
         3: ifnonnull     37
         6: ldc           #3                  // class juc/visibility/Singleton
         8: dup
         9: astore_0
        10: monitorenter
        11: getstatic     #2                  // Field INSTANCE:Ljuc/visibility/DCLSingleton;
        14: ifnonnull     27
        17: new           #4                  // class juc/visibility/DCLSingleton
        20: dup
        21: invokespecial #5                  // Method "<init>":()V
        24: putstatic     #2                  // Field INSTANCE:Ljuc/visibility/DCLSingleton;
        27: aload_0
        28: monitorexit
        29: goto          37
        32: astore_1
        33: aload_0
        34: monitorexit
        35: aload_1
        36: athrow
        37: getstatic     #2                  // Field INSTANCE:Ljuc/visibility/DCLSingleton;
        40: areturn
      Exception table:

其中

• 17 表示创建对象，将对象引用入栈 // new Singleton
• 20 表示复制一份对象引用 // 引用地址
• 21 表示利用一个对象引用，调用构造方法
• 24 表示利用一个对象引用，赋值给 static INSTANCE

也许 jvm 会优化为：先执行 24，再执行 21。如果两个线程 t1，t2 按如下时间序列执行：

image.png

0: getstatic 这行代码在 monitor 控制之外，可以越过 monitor 读取INSTANCE 变量的值，这时 t1 还未完全将构造方法执行完毕，如果在构造方法中要执行很多初始化操作，那么 t2 拿到的是将是一个未初始化完毕的单例。

解决：
对 INSTANCE 使用 volatile 修饰即可，可以禁用指令重排，但要注意在 JDK 5 以上的版本的 volatile 才会真正有效：

public class DCLSingleton {
    private DCLSingleton() { }
    private static volatile DCLSingleton INSTANCE = null;
    public static DCLSingleton getInstance() {
        if(INSTANCE == null) {
            synchronized(Singleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new DCLSingleton();
                }
            }
        }
        return INSTANCE;
    }
}

         0: getstatic     #2                  // Field INSTANCE:Ljuc/visibility/DCLSingleton;
         3: ifnonnull     37
         6: ldc           #3                  // class juc/visibility/Singleton
         8: dup
         9: astore_0
        10: monitorenter  //-----------------------> 保证原子性、可见性
        11: getstatic     #2                  // Field INSTANCE:Ljuc/visibility/DCLSingleton;
        14: ifnonnull     27
        17: new           #4                  // class juc/visibility/DCLSingleton
        20: dup
        21: invokespecial #5                  // Method "<init>":()V
        24: putstatic     #2                  // Field INSTANCE:Ljuc/visibility/DCLSingleton;
        // -------------------------------------> 加入对 INSTANCE 变量的写屏障
        27: aload_0
        28: monitorexit  //------------------------> 保证原子性、可见性
        29: goto          37
        32: astore_1
        33: aload_0
        34: monitorexit
        35: aload_1
        36: athrow
        37: getstatic     #2                  // Field INSTANCE:Ljuc/visibility/DCLSingleton;
        40: areturn

读写 volatile 变量时会加入内存屏障（Memory Barrier（Memory Fence）），保证下面两点：

• 可见性
  写屏障（sfence）保证在该屏障之前的 t1 对共享变量的改动，都同步到主存当中
  读屏障（lfence）保证在该屏障之后 t2 对共享变量的读取，加载的是主存中最新数据

• 有序性
  写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
  读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

  
  
  image.png

更底层是读写变量时使用 lock 指令来实现多核 CPU 之间的可见性与有序性

八、happens-before

happens-before 规定了对共享变量的写操作对其它线程的读操作可见，它是可见性与有序性的一套规则总结
抛开以下 happens-before 规则，JMM 并不能保证一个线程对共享变量的写，对于其它线程对该共享变量的读可见

1.线程解锁 m 之前对变量的写，对于接下来对 m 加锁的其它线程对该变量的读可见：

static int x;
static Object m = new Object();
new Thread(() -> {
    synchronized (m) {
        x = 10;
    }
}, "t1").start();
new Thread(() ->{
    synchronized (m) {
        System.out.println(x);
    }
}, "t2").start();

2.线程对 volatile 变量的写，对接下来其它线程对该变量的读可见：

volatile static int x;
new Thread(()->{
    x = 10;
},"t1").start();
new Thread(()->{
    System.out.println(x);
},"t2").start();

3.线程 start 前对变量的写，对该线程开始后对该变量的读可见：

static int x;
x = 10;
new Thread(()->{
    System.out.println(x);
},"t2").start();

4.线程结束前对变量的写，对其它线程得知它结束后的读可见（比如其它线程调用 t1.isAlive() 或 t1.join()等待它结束）

static int x;
Thread t1 = new Thread(()->{
    x = 10;
},"t1");
t1.start();
t1.join();
System.out.println(x);

5.线程 t1 打断 t2（interrupt）前对变量的写，对于其他线程得知 t2 被打断后对变量的读可见（通过t2.interrupted 或 t2.isInterrupted）

static int x;
public static void main(String[] args) {
    Thread t2 = new Thread(()->{
        while(true) {
            if(Thread.currentThread().isInterrupted()) {
                System.out.println(x);
                break;
            }
        }
    },"t2");
    t2.start();
    new Thread(()->{
        sleep(1);
        x = 10;
        t2.interrupt();
    },"t1").start();
    while(!t2.isInterrupted()) {
        Thread.yield();
    }
    System.out.println(x);
}

6.对变量默认值（0，false，null）的写，对其它线程对该变量的读可见

7.具有传递性，如果 x hb-> y 并且 y hb-> z 那么有 x hb-> z ，配合 volatile 的防指令重排，有下面的例子

volatile static int x;
static int y;
new Thread(()->{
    y = 10;
    x = 20;
},"t1").start();
new Thread(()->{
    // x=20 对 t2 可见, 同时 y=10 也对 t2 可见
    System.out.println(x);
},"t2").start();