第四章 - 共享模型之内存

第四章 - 共享模型之内存 第四章 - 共享模型之内存

之前讲的synchronized底层Monitor主要关注的是访问共享变量时，保证临界区代码的 原子性 。下面进一步深入学习共享变量在多线程间的【可见性】问题与多条指令执行时的【有序性】问题

Java 内存模型

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

原子性 - 保证指令不会受 线程上下文切换的影响可见性 - 保证指令不会受 cpu 缓存的影响 (JIT对热点代码的缓存优化)有序性 - 保证指令不会受 cpu 指令并行优化的影响 可见性 (重点) 退不出的循环

先来看一个现象，main线程对run变量的修改对于t线程不可见，导致了 t 线程无法停止

@Slf4j(topic = "c.Test32")
public class Test32 {

    static boolean run = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(run){
              
            }
        });
        t.start();

        sleep(1);
        log.debug("修改run，欲停止 t");
        run = false; // 线程t不会如预想的停下来
    }
}

为什么会出现对run变量的不可见性呢？分析一下：

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

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

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

解决方法

volatile（易变关键字）

它可以用来修饰成员变量和静态成员变量，它可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程 *** 作 volatile 变量都是直接 *** 作主存

@Slf4j(topic = "c.Test32")
public class Test32 {
    // 易变
    volatile static boolean run = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (run) {

            }
        });
        t.start();

        sleep(1);
        log.debug("修改run，欲停止 t");
        run = false; // 线程t不会如预想的停下来
    }
}

运行程序，可以看到程序正常退出

使用synchronized关键字也有相同的效果，在Java内存模型中，synchronized规定，线程在加锁时， 先清空工作内存 → 在主内存中拷贝最新变量的副本到工作内存 → 执行完代码 → 将更改后的共享变量的值刷新到主内存中 → 释放互斥锁。

@Slf4j(topic = "c.Test32")
public class Test32 {

    static boolean run = true;

    // 锁对象
    final static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (run) {
                synchronized (lock) {
                    if (!run) {
                        break;
                    }
                }
            }
        });
        t.start();

        sleep(1);
        log.debug("修改run，欲停止 t");
        synchronized (lock) {
            run = false;
        }
    }
}

可见性 vs 原子性

前面例子体现的实际就是可见性，它保证的是在多个线程之间一个线程对 volatile 变量的修改对另一个线程可见， 而不能保证原子性。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 是属于重量级 *** 作，性能相对较低。

如果在前面示例的死循环中加入 System.out.println( ) 会发现即使不加 volatile 修饰符，线程 t 也能正确看到 对 run 变量的修改了，想一想为什么？

因为println方法里面有synchronized修饰。还有那个等烟的示例, 为啥没有出现可见性问题? 和synchrozized是一个道理。

@Slf4j(topic = "c.Test32")
public class Test32 {

    static boolean run = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (run) {
                // 如果打印一句话
                // 此时就可以结束, 因为println方法中, 使用到了synchronized
                // synchronized可以保证原子性、可见性、有序性
                System.out.println("123");
            }
        });
        t.start();
        log.debug("修改run，欲停止 t");
        run = false;
    }
}

程序正常结束了…

模式之两阶段终止

当我们在执行线程1 时，想要终止线程2，这时就需要使用interrupt方法来优雅的停止线程2。这是我们之前的做法

使用volatile关键字来实现两阶段终止模式

@Slf4j(topic = "c.TwoPhaseTermination")
public class Test13 {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();

        Thread.sleep(3500);
        log.debug("停止监控");
        tpt.stop();
    }
}

@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination {
    // 监控线程
    private Thread monitorThread;
    // 停止标记
    private volatile boolean stop = false;

    // 启动监控线程
    public void start() {
        monitorThread = new Thread(() -> {
            while (true) {
                // 是否被打断
                if (stop) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("执行监控记录");
                } catch (InterruptedException ignored) {
                }
            }
        }, "monitor");
        monitorThread.start();
    }

    // 停止监控线程
    public void stop() {
        stop = true;
        // 直接打断，不让执行sleep
        monitorThread.interrupt();
    }
}

模式之 Balking 定义

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

如上例的两阶段终止模式，如果多次调用监控线程的start方法，会创建多个监控线程，但实际上，监控线程一个就够了。

@Slf4j(topic = "c.TwoPhaseTermination")
public class Test13 {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();
        tpt.start();
        tpt.start();

        Thread.sleep(3500);
        log.debug("停止监控");
        tpt.stop();
    }
}

@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination {
    // 监控线程
    private Thread monitorThread;
    // 停止标记
    private volatile boolean stop = false;

    // 启动监控线程
    public void start() {
        monitorThread = new Thread(() -> {
            while (true) {
                // 是否被打断
                if (stop) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("执行监控记录");
                } catch (InterruptedException ignored) {
                }
            }
        }, "monitor");
        monitorThread.start();
    }

    // 停止监控线程
    public void stop() {
        stop = true;
        // 直接打断，不让执行sleep
        monitorThread.interrupt();
    }
}

当前端页面多次点击按钮调用 start 时，会有多个线程执行相同的 *** 作

修改后

@Slf4j(topic = "c.TwoPhaseTermination")
public class Test13 {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();
        tpt.start();
        tpt.start();

        Thread.sleep(3500);
        log.debug("停止监控");
        tpt.stop();
    }
}

@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination {
    // 监控线程
    private Thread monitorThread;
    // 停止标记
    private volatile boolean stop = false;
    // 判断是否执行过 start 方法
    private boolean starting = false;

    // 启动监控线程
    public void start() {
        synchronized (this) {
            if (starting) { 
                return;
            }
            starting = true;
        }

        monitorThread = new Thread(() -> {
            while (true) {
                // 是否被打断
                if (stop) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("执行监控记录");
                } catch (InterruptedException ignored) {
                }
            }
        }, "monitor");
        monitorThread.start();
    }

    // 停止监控线程
    public void stop() {
        stop = true;
        // 直接打断，不让执行sleep
        monitorThread.interrupt();
    }
}

它还经常用来实现线程安全的单例

public final class Singleton {

  private Singleton() {
  }

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

    return INSTANCE;
  }
} 

有序性 (重点)

JVM 会在不影响正确性的前提下，可以调整语句的执行顺序，思考下面一段代码

static int i;
static int j;

// 在某个线程内执行如下赋值 *** 作
i = ...; 
j = ...;

可以看到，至于是先执行 i 还是 先执行 j ，对最终的结果不会产生影响。所以，上面代码真正执行时，既可以是

i = ...; 
j = ...;

也可以是

j = ...;
i = ...;

这种特性称之为『指令重排』，多线程下『指令重排』会影响正确性。为什么要有重排指令这项优化呢？从 CPU执行指令的原理来理解一下吧 指令级并行原理 名词

Clock Cycle Time

主频的概念大家接触的比较多，而 CPU 的 Clock Cycle Time（时钟周期时间），等于主频的倒数，意思是 CPU 能够识别的最小时间单位，比如说 4G 主频的 CPU 的 Clock Cycle Time 就是 0.25 ns，作为对比，我们墙上挂钟的Cycle Time 是 1s例如，运行一条加法指令一般需要一个时钟周期时间

CPI

有的指令需要更多的时钟周期时间，所以引出了 CPI （Cycles Per Instruction）指令平均时钟周期数

IPC

IPC（Instruction Per Clock Cycle） 即 CPI 的倒数，表示每个时钟周期能够运行的指令数

CPU 执行时间

程序的 CPU 执行时间，即我们前面提到的 user + system 时间，可以用下面的公式来表示

程序 CPU 执行时间 = 指令数 * CPI * Clock Cycle Time

鱼罐头的故事

加工一条鱼需要 50 分钟，只能一条鱼、一条鱼顺序加工…

可以将每个鱼罐头的加工流程细分为 5 个步骤：

去鳞清洗 10分钟蒸煮沥水 10分钟加注汤料 10分钟杀菌出锅 10分钟真空封罐 10分钟

即使只有一个工人，最理想的情况是：他能够在 10 分钟内同时做好这 5 件事，因为对第一条鱼的真空装罐，不会影响对第二条鱼的杀菌出锅… 指令重排序优化

事实上，现代处理器会设计为一个时钟周期完成一条执行时间最长的 CPU 指令。为什么这么做呢？可以想到指令还可以再划分成一个个更小的阶段，例如，每条指令都可以分为：

取指令 -> 指令译码 -> 执行指令 -> 内存访问 -> 数据写回 这 5 个阶段

术语参考：

instruction fetch (IF)instruction decode (ID)execute (EX)memory access (MEM)register write back (WB)

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

提示：

分阶段，分工是提升效率的关键！

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

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

// 不能重排的例子
int a = 10; // 指令1
int b = a - 5; // 指令2

支持流水线的处理器

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

提示：

奔腾四（Pentium 4）支持高达 35 级流水线，但由于功耗太高被废弃

SuperScalar 处理器

大多数处理器包含多个执行单元，并不是所有计算功能都集中在一起，可以再细分为整数运算单元、浮点数运算单元等，这样可以把多条指令也可以做到并行获取、译码等，CPU 可以在一个时钟周期内，执行多于一条指令，IPC > 1

诡异的结果

int num = 0;

boolean ready = false; 

// 线程1 执行此方法
public void actor1(I_Result r) {
	 if(ready) {
	 	r.r1 = num + num;
	 } 
	 else {
	 	r.r1 = 1;
	 }
}

// 线程2 执行此方法
public void actor2(I_Result r) {
	 num = 2;
	 ready = true;
}

线程1执行actor1方法, 线程2执行actor2方法

I_Result 是一个对象，有一个属性 r1 用来保存结果，问，可能的结果有几种？有同学这么分析

情况1：线程1 先执行，这时 ready = false，所以进入 else 分支结果为 1情况2：线程2 先执行 num = 2，但没来得及执行 ready = true，线程1 执行，还是进入 else 分支，结果为1情况3：线程2 执行到 ready = true，线程1 执行，这回进入 if 分支，结果为 4（因为 num 已经执行过了） 但我告诉你，结果还有可能是 0 ，信不信吧！这种情况下是：线程2 执行 ready = true，切换到线程1，进入 if 分支，相加为 0，再切换回线程2 执行 num = 2相信很多人已经晕了 

这种现象叫做指令重排，是 JIT 编译器在运行时的一些优化，这个现象需要通过大量测试才能复现

借助 java 并发压测工具 jcstress

mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk.jcstress -DarchetypeArtifactId=jcstress-java-test-archetype -DarchetypeVersion=0.5 -DgroupId=cn.itcast -DartifactId=ordering -Dversion=1.0

创建 maven 项目，提供如下测试类

@JCStressTest
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class ConcurrencyTest {

    int num = 0;
    boolean ready = false;
    @Actor
    public void actor1(I_Result r) {
        if(ready) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }

    @Actor
    public void actor2(I_Result r) {
        num = 2;
        ready = true;
    }

}

执行

mvn clean install 
java -jar target/jcstress.jar

会输出我们感兴趣的结果，摘录其中一次结果：

可以看到，出现结果为 0 的情况虽然次数相对很少，但毕竟是出现了。

解决方法

volatile 修饰的变量，可以禁用指令重排

@JCStressTest
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class ConcurrencyTest {

    int num = 0;
    volatile boolean ready = false;
    @Actor
    public void actor1(I_Result r) {
        if(ready) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }

    @Actor
    public void actor2(I_Result r) {
        num = 2;
        ready = true;
    }

}

加上 volatile 后，可以看到测试结果没有出现 0 的情况了…

volatile 原理 (重点)

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

对 volatile 变量的写指令后会加入写屏障。(保证写屏障之前的写 *** 作, 都能同步到主存中)对 volatile 变量的读指令前会加入读屏障。(保证读屏障之后的读 *** 作, 都能读到主存的数据) volatile是如何保证可见性 (重点)

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

public void actor2(I_Result r) {
     num = 2;
     ready = true; // ready是被volatile修饰的，赋值带写屏障
     // 写屏障
     // 写屏障之前对共享变量的改动, 都同步到主存中, 包括 num、ready
}

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

public void actor1(I_Result r) {
	 // 读屏障之后的代码，只要是涉及到读取的，读取到的都是主存中的最新数据
	 // ready是被volatile修饰的 ，读取值带读屏障
   // 读屏障
	 if(ready) {	// ready, 读取的就是主存中的新值
	 	r.r1 = num + num; // num, 读取的也是主存中的新值
	 } else {
	 	r.r1 = 1;
	 }
}

volatile是如何保证有序性

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

public void actor2(I_Result r) {
 num = 2;
 ready = true; //  ready是被volatile修饰的，赋值带写屏障
 // 写屏障
}

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

public void actor1(I_Result r) {
	 // 读屏障
	 // ready是被volatile修饰的，读取值带读屏障
	 if(ready) {
	 	r.r1 = num + num;
	 } else {
	 	r.r1 = 1;
	 }
}

volatile不能解决指令交错 (不能解决原子性)：

写屏障仅仅是保证之后的读能够读到最新的结果，但不能保证其它线程的读, 跑到当前线程的前面去有序性的保证也只是保证了当前线程内相关代码不被重排序下图t2线程, 就先读取了i=0, 此时还是会出现指令交错的现象, 可以使用synchronized来解决原子性

重排序也需要遵守一定规则

指令重排序 *** 作不会对存在数据依赖关系的 *** 作进行重排序。比如：a=1;b=a; 这个指令序列，由于第二个 *** 作依赖于第一个 *** 作，所以在编译时和处理器运行时这两个 *** 作不会被重排序。重排序是为了优化性能，但是不管怎么重排序，单线程下程序的执行结果不能被改变。 比如：a=1;b=2;c=a+b; 这三个 *** 作，第一步（a=1;) 和 第二步( b=2;)由于不存在数据依赖关系，所以可能会发生重排序，但是 c=a+b; 这个 *** 作是不会被重排序的，因为需要保证最终的结果一定是 c=a+b=3; 。

指令重排序 在 单线程模式下是一定会保证最终结果的正确性， 但是在多线程环境下，问题就出来了。

解决方法：volatile 修饰的变量，可以禁用指令重排

注意：

使用synchronized并不能解决有序性问题，但是如果是该变量整个都在synchronized代码块的保护范围内，那么变量就不会被多个线程同时 *** 作，也不用考虑有序性问题！在这种情况下相当于解决了重排序问题！参考下面double-checked locking 问题里的代码，第一个代码片段中的instance变量都在synchronized代码块中，第二个代码片段中instance不全在synchronized中所以产生了问题。

double-checked locking (双重检查锁) 问题 (重点)

首先synchronized可以保证它的临界区的资源是 原子性、可见性、有序性的, 有序性的前提是, 在synchronized代码块中的共享变量, 不会在代码块外使用到, 否则有序性不能被保证, 只能使用volatile来保证有序性下面代码的第二个双重检查单例, 就出现了这个问题(在synchronized外使用到了INSTANCE), 此时synchronized就不能防止指令重排, 确保不了指令的有序性以著名的double-checked locking(双重检查锁) 单例模式为例，这是volatile最常使用的地方。

// 最开始的单例模式是这样的
public final class Singleton {
    private Singleton() { }
    private static Singleton INSTANCE = null;
    public static Singleton getInstance() {
	    
	    synchronized(Singleton.class) {
	    	if (INSTANCE == null) { // t1
	    		INSTANCE = new Singleton();
	        }
	    }
        return INSTANCE;
    }
}


public final class Singleton {
    private Singleton() { }
    private static Singleton INSTANCE = null;
    public static Singleton getInstance() {
        if(INSTANCE == null) { // t2
            // 首次访问会同步，而之后的使用没有 synchronized
            synchronized(Singleton.class) {
                if (INSTANCE == null) { // t1
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}
// 但是上面的if(INSTANCE == null)判断代码没有在同步代码块synchronized中，
// 不能享有synchronized保证的原子性、可见性、以及有序性。所以可能会导致 指令重排

以上的实现特点是：

懒汉式单例首次使用 getInstance( ) 才使用 synchronized 加锁，后续使用时无需加锁 (也就是上面的第二种单例模式)有隐含的: 但很关键的一点：第一个 if 使用了 INSTANCE 变量，是在同步块之外, 这样会导致synchronized无法保证指令的有序性, 此时可能会导致指令重排问题

注意:

在多线程环境下，上面的代码是有问题的，getInstance 方法对应的字节码为：

0: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
3: ifnonnull 37 // 判断是否不为空 if(INSTANCE != null) 如果为空跳转到37
// ldc是获得类对象 Singleton.class
6: ldc #3 // class cn/itcast/n5/Singleton
// 复制 *** 作数栈栈顶的值放入栈顶, 将类对象的引用地址复制了一份
8: dup
//  *** 作数栈栈顶的值d出，即将对象的引用地址存入到局部变量表中
// 将类对象的引用地址复制了一份，是为了将来synchronized解锁用
9: astore_0
// 进入同步代码块
10: monitorenter
11: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
14: ifnonnull 27 // 判断是否不为空 if(INSTANCE != null) 如果为空跳转到37
// 新建一个实例
17: new #3 // class cn/itcast/n5/Singleton
// 复制了一个实例的引用
20: dup
// 通过这个复制的引用调用它的构造方法
21: invokespecial #4 // Method "":()V
// 最开始new的这个引用用来进行赋值 *** 作
24: putstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton; INSTANCE = new Singleton();
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:Lcn/itcast/n5/Singleton;
40: areturn

其中

17 表示创建对象，将对象引用入栈 // new Singleton20 表示复制一份对象引用 // 复制了引用地址, 解锁使用21 表示利用一个对象引用，调用构造方法 // 根据复制的引用地址调用构造方法24 表示利用一个对象引用，赋值给 static INSTANCE // 最开始new的这个引用用来进行赋值 *** 作

可能jvm 会优化为：先执行 24(赋值)，再执行 21(构造方法)。如果两个线程 t1，t2 按如下时间序列执行：

通过上面的字节码发现, 这一步INSTANCE = new Singleton(); *** 作不是一个原子 *** 作, 它分为21, 24两个指令, 此时可能就会发生指令重排的问题

关键在于 0: getstatic 这行代码在 monitor 控制之外，它就像之前举例中不守规则的人一样，可以越过 monitor 读取 INSTANCE 变量的值这时 t1 还未完全将构造方法执行完毕，如果在构造方法中要执行很多初始化 *** 作，那么 t2 拿到的是将是一个未初始化完毕的单例对 INSTANCE 使用 volatile 修饰即可，就可以禁用指令重排，但要注意在 JDK 5 以上的版本的 volatile 才会真正有效 double-checked locking 关于指令重排的解决

加上 volatile

public final class Singleton {
    private Singleton() { }
    private static volatile Singleton INSTANCE = null;
    public static Singleton getInstance() {
        // 实例没创建，才会进入内部的 synchronized代码块
        if (INSTANCE == null) {
            synchronized (Singleton.class) { // t2
                // 也许有其它线程已经创建实例，所以再判断一次
                if (INSTANCE == null) { // t1
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

字节码上看不出来 volatile 指令的效果

// -------------------------------------> 加入对 INSTANCE 变量的读屏障, 防止读屏障之后的代码跑到前面去
0: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
3: ifnonnull 37
6: ldc #3 // class cn/itcast/n5/Singleton
8: dup
9: astore_0
10: monitorenter -----------------------> 保证原子性、可见性
11: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
14: ifnonnull 27
17: new #3 // class cn/itcast/n5/Singleton
20: dup
21: invokespecial #4 // Method "":()V
24: putstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
// -------------------------------------> 加入对 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:Lcn/itcast/n5/Singleton;
40: areturn

如上面的注释内容所示，读写 volatile 变量 *** 作（即getstatic *** 作和putstatic *** 作）时会加入内存屏障（Memory Barrier（Memory Fence）），保证下面两点：

可见性

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

写屏障 会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后读屏障 会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前 更底层是读写变量时使用 lock 指令来多核 CPU 之间的可见性与有序性

加上volatile之后, 保证了指令的有序性, 不会发生指令重排, 21就不会跑到24之后执行了

如果是0行代码跑到24之前去执行，即t2线程打断了t1线程去执行，发生指令交错。如下图

那也是没问题的，因为此时 INSTANCE == null，往下执行，被挡在了synchronized那里了，会等待t1执行完（t1有锁）。

可能会有疑问，为什么加了synchronized或者volatile之后，会发生指令重排了?

INSTANCE没有完全受synchronized保护，还有一个if(INSTANCE==null)在代码块之外，其他线程自然能去执行到，又不会被挡住。volatile保证有序性，也只是保证本线程的相关代码的有序，可以看到，t1、t2线程的相关代码都是有序的，但是线程之间进行了指令交错。

小结

synchronized 既能保证原子性、可见性、有序性，其中有序性是在该共享变量完全被synchronized 所接管（包括共享变量的读写 *** 作），上面的例子中synchronized 外面的 if (INSTANCE == null) 中的INSTANCE读 *** 作没有被synchronized 接管，因此无法保证INSTANCE共享变量的有序性（即不能防止指令重排）。对共享变量加volatile关键字可以保证可见性和有序性，但是不能保证原子性（即不能防止指令交错）。 happens-before (对共享变量的写 *** 作,对其它线程的读 *** 作可见)

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

下面说的变量都是指 成员变量或静态成员变量

方式一 :

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

synchronized锁, 保证了可见性

// 假设 线程1 先执行	
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();

// 10

方式二 :

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

volatile修饰的变量, 通过写屏障, 共享到主存中, 其他线程通过读屏障, 读取主存的数据

// 假设 线程1 先执行	
volatile static int x;
  
  new Thread(()->{
   	x = 10;
  },"t1").start();
  
  new Thread(()->{
   	System.out.println(x);
  },"t2").start();

方式三:

线程 start( ) 前对变量的写，对该线程开始后对该变量的读可见

线程还没启动时, 修改变量的值, 在启动线程后, 获取的变量值, 肯定是修改过的

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

方式四 :

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

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

方式五 :

线程 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); // 10, 打断了, 读取的也是打断前修改的值
                  break;
              }
          }
      },"t2");
      t2.start(); 
      
      new Thread(()->{
          sleep(1);
          x = 10;
          t2.interrupt();
      },"t1").start();
      
      while(!t2.isInterrupted()) {
          Thread.yield();
      }
      System.out.println(x);	// 10
  }

方式五 :

对变量默认值（0，false，null）的写，对其它线程对该变量的 读可见 (最基本)具有传递性，如果 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();

总结

volatile主要用在一个线程改,多个线程读时的来保证可见性，和double-checked locking模式中保证synchronized代码块外的共享变量的指令重排序问题

习题 balking 模式习题

希望 doInit( ) 方法仅被调用一次，下面的实现是否有问题，为什么？

public class TestVolatile {

    volatile boolean initialized = false;

    void init() {
        if (initialized) {
            return;
        }
        doInit();
        initialized = true;
    }

    private void doInit() {

    }

}

有问题，volatile无法保证原子性; 当多个线程同时调用init( )方法时, 此时都进入到if判断, 因为都为false, 所以都调用doInit( )方法, 此时就调用了多次

解决方法: 对init( )方法的方法体, 通过synchronized加锁, 防止多个线程访问共享资源导致的安全问题;

@Slf4j(topic = "c.BigRoomTest")
public class BigRoomTest {

    volatile static boolean initialized = false;
    final static Object obj = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            init();
        }, "t1").start();

        new Thread(() -> {
            init();
        }, "t2").start();
    }

    static void init() {
        synchronized (obj) {
            if (initialized) {
                return;
            }
            doInit();
            initialized = true;
        }
    }

    private static void doInit() {
        log.debug("init...");
    }
}

线程安全单例模式 (重点)

单例模式有很多实现方法，饿汉、懒汉、静态内部类、枚举类，试分析每种实现下获取单例对象（即调用 getInstance）时的线程安全，并思考注释中的问题

饿汉式：类加载就会导致该单实例对象被创建懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

实现1： 饿汉式

// 问题1：为什么加 final? 防止子类继承后更改
// 问题2：如果实现了序列化接口, 还要做什么来防止反序列化破坏单例? 如果进行反序列化的时候会生成新的对象，这样跟单例模式生成的对象是不同的。要解决直接加上readResolve()方法就行了，如下所示
public final class Singleton implements Serializable {
    // 问题3：为什么设置为私有? 防止其它类中使用new生成新的实例? 
    // 是否能防止反射创建新的实例? 不能。
    private Singleton() {}
    // 问题4：这样初始化是否能保证单例对象创建时的线程安全? 能，这是类变量，是jvm在类加载阶段就进行了初始化，jvm保证了此 *** 作的线程安全性
    private static final Singleton INSTANCE = new Singleton();
    // 问题5：为什么提供静态方法而不是直接将 INSTANCE 设置为 public, 说出你知道的理由。
    //1.提供更好的封装性；2.提供泛型的支持
    public static Singleton getInstance() {
        return INSTANCE;
    }
    public Object readResolve() {
        return INSTANCE;
    }
}

问题1 : 加final为了防止有子类, 因为子类可以重写父类的方法问题2 : 首先通过反序列化 *** 作, 也是可以创建一个对象的, 破坏了单例, 可以使用readResolve方法并返回instance对象, 当反序列化的时候就会调用自己写的readResolve方法，这样返回的就还是同一个对象，不会是新的对象问题3 : 私有化构造器, 防止外部通过构造器来创建对象; 但不能防止反射来创建对象问题4 : 因为单例对象是static的, 静态成员变量的初始化 *** 作是在类加载阶段完成, 由JVM保证其线程安全 (这其实是利用了ClassLoader的线程安全机制。ClassLoader的loadClass方法在加载类的时候使用了synchronized关键字。)问题5 : 通过向外提供公共方法, 体现了更好的封装性, 可以在方法内实现懒加载的单例; 可以提供泛型等补充 : 任何一个readObject方法，不管是显式的还是默认的，它都会返回一个新建的实例，这个新建的实例不同于该类初始化时创建的实例。

实现2： 饿汉式，因为枚举的变量，底层是通过public static final来修饰的, 类加载就创建了，所以是饿汉式

// 问题1：枚举单例是如何限制实例个数的? 创建枚举类的时候就已经定义好了，每个枚举常量其实就是枚举类的一个静态成员变量
// 问题2：枚举单例在创建时是否有并发问题? 没有，这是静态成员变量，在类加载阶段就创建好了
// 问题3：枚举单例能否被反射破坏单例? 不能
// 问题4：枚举单例能否被反序列化破坏单例? 枚举类默认实现了序列化接口，枚举类已经考虑到此问题，无需担心破坏单例
// 问题5：枚举单例属于懒汉式还是饿汉式? 饿汉式
// 问题6：枚举单例如果希望加入一些单例创建时的初始化逻辑该如何做的? 加构造方法就行了
enum Singleton {
 INSTANCE;
}

问题1 : 枚举类中, 只有一个INSTANCE, 就确保了它是单例的

问题2 : 没有并发问题, 是线程安全的, 因为枚举单例底层是一个静态成员变量, 它是通过类加载器的加载而创建的, 确保了线程安全

问题3 : 反射无法破坏枚举单例, 主要通过反射, newInstance的时候, 会在该方法中作判断, 如果检查是枚举类型, 就会抛出异常。

if ((this.clazz.getModifiers() & 16384) != 0)
throw new IllegalArgumentException(“Cannot reflectively create enum objects”);

问题4 : 反序列化不能破坏, 枚举类默认也实习了序列号接口; 枚举类考虑到了这个问题, 不会破坏单例, 通过反序列化得到的并不是同一个单例对象; 除此之外, 还可以写上readResolve方法,

问题 5 : 属于饿汉式, 静态成员变量, 通过类加载器的时候就加载了。

问题 6 : 加构造方法

实现3：懒汉式

public final class Singleton {
    private Singleton() { }
    private static Singleton INSTANCE = null;
    // 分析这里的线程安全, 并说明有什么缺点? 
		// synchronized 加在静态方法上，可以保证线程安全。缺点就是锁的范围过大.
    public static synchronized Singleton getInstance() {
        if( INSTANCE != null ){
            return INSTANCE;
        }
        INSTANCE = new Singleton();
        return INSTANCE;
    }
}

上面是一个懒汉式的单例, 代码存在性能问题: 当单例对象已经创建好了, 多个线程访问getInstance()方法, 仍然会获取锁, 同步 *** 作, 性能很低, 此时出现重复判断, 因此要使用双重检查

实现4：DCL 懒汉式

public final class Singleton {
    private Singleton() { }
    // 问题1：解释为什么要加 volatile? 为了防止重排序问题
    private static volatile Singleton INSTANCE = null;

    // 问题2：对比实现3, 说出这样做的意义? 提高了效率
    public static Singleton getInstance() {
        if (INSTANCE != null) {
            return INSTANCE;
        }
        synchronized (Singleton.class) {
            // 问题3：为什么还要在这里加为空判断, 之前不是判断过了吗？这是为了第一次判断时的并发问题。
            if (INSTANCE != null) { 
                return INSTANCE;
            }
            INSTANCE = new Singleton();
            return INSTANCE;
        }
    }
}

问题1 : 因为在synchronized外部使用到了共享变量INSTANCE, 所以synchronized无法保证INSTANCE 的有序性, 又因为INSTANCE = new Singleton()不是一个原子 *** 作, 可分为多个指令; 此时通过指令重排, 可能会造成INSTANCE还未初始化, 就赋值的现象, 所以要给共享变量INSTANCE加上volatile, 禁止指令重排问题2 : 增加了双重判断, 如果存在了单例对象, 别的线程再进来就无需加锁判断, 大大提高性能问题3 : 防止多线程并发导致不安全的问题: 防止单例对象被重复创建, 当t1,t2线程都调用getInstance( )方法, 它们都判断单例对象为空, 还没有创建 ;

此时t1先获取到锁对象, 进入到synchronized中, 此时创建对象, 返回单例对象, 释放锁;这时候t2获得了锁对象, 如果在代码块中没有if判断, 则线程2认为没有单例对象, 因为在代码块外判断的时候就没有, 所以t2就还是会创建单例对象. 此时就重复创建了

实现5：懒汉式

public final class Singleton {
    private Singleton() { }
    // 问题1：属于懒汉式还是饿汉式? 懒汉式，这是一个静态内部类。类加载本身就是懒惰的，在没有调用getInstance方法时是没有执行LazyHolder内部类的类加载 *** 作的。
    private static class LazyHolder {
        static final Singleton INSTANCE = new Singleton();
    }
    // 问题2：在创建时是否有并发问题? 这是线程安全的，类加载时，jvm会保证类加载 *** 作的线程安全
    public static Singleton getInstance() {
        return LazyHolder.INSTANCE;
    }
}

问题 1 : 懒汉式，这是一个静态内部类。类加载本身就是懒惰的，在没有调用getInstance方法时是没有执行LazyHolder内部类的类加载 *** 作的。静态内部类不会随着外部类的加载而加载, 这是静态内部类和静态变量的区别问题 2 : 不会有并发问题, 因为是通过类加载创建的单例, JVM保证不会出现线程安全。 本章小结

本章重点讲解了 JMM 中的

可见性 - 由 JVM 缓存优化引起; (JIT即时编译器, 通过对热点代码的优化)有序性 - 由 JVM 指令重排序优化引起; (提高指令的执行效率, 类似流水线系统)happens-before 规则; (happens-before 规定了对共享变量的写 *** 作对其它线程的读 *** 作可见，它是可见性与有序性的一套规则总结。) 原理方面

volatile (读写屏障) 模式方面

两阶段终止模式的 volatile 改进同步模式之 balking (犹豫模式)