[Java知识库]4、Java内存模型、volatile原理、CPU缓存结构、balking模式、单例模式

本章内容

上一章讲解的Monitor主要关注的是访问共享变量时，保证临界区代码的原子性

这一张进一步深入学习共享变量在多线程之间的【可见性】问题与多条指令执行时的【有序性】问题

1、Java内存模型

JMM即Java Menory Model，它定义了主存，工作内存的抽象概念，底层对应着CPU寄存器、缓存、硬件内存、CPU指令优化等。

JMM 体现在以下几个方面

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

2、可见性

退不出的循环

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

static boolean run = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (run) {
            }
        });
        t1.start();
        Thread.sleep(1000);
        run = false;
    }

t线程没有如预期的停下来

分析一下：

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

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

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

解决办法

volatile （易变关键字）

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

可见性 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是属于重量级的，性能相对更低
如果在前面示例的死循环中加入System.out.println()会发现及时不加volatile修饰乳，线程t也能正确看到对run变量的修改，为什么？

println内部有synchronized关键字

3、CPU缓存结构原理

1、CPU缓存结构

查看cpu缓存

? root@yihang01 ~ lscpu
Architecture: x86_64
CPU op-mode(s): 32-bit, 64-bit
Byte Order: Little Endian
CPU(s): 1
On-line CPU(s) list: 0
Thread(s) per core: 1
Core(s) per socket: 1
Socket(s): 1
NUMA node(s): 1
Vendor ID: GenuineIntel
CPU family: 6
Model: 142
Model name: Intel(R) Core(TM) i7-8565U CPU @ 1.80GHz
Stepping: 11
CPU MHz: 1992.002
BogoMIPS: 3984.00
Hypervisor vendor: VMware
Virtualization type: full
L1d cache: 32K
L1i cache: 32K
L2 cache: 256K
L3 cache: 8192K
NUMA node0 CPU(s): 0

速度比较

查看cpu缓存行

? root@yihang01 ~ cat /sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size
64

cpu拿到的内存地址格式是这样的

[高位组标记][低位索引][偏移量]

2、CPU缓存读

读取数据流程如下

• 根据低位，计算在缓存中的索引
• 判断是否有效
  • 0 去内存读取新数据更新缓存行
  • 1 再去比较高位组标记是否一致
    • 一致，根据偏移量返回缓存数据
    • 不一致，去内存读取新数据更新缓存行

3、CPU缓存一致性

MESI协议

1. E、S、M状态的缓存行都可以满足CPU的读请求
2. E状态的缓存行，有写请求，会将状态改为M，这时并不触发主存的写
3. E状态的缓存行，必须监听该缓存行的读操作，如果有，要变为S状态
   
4. M状态的缓存行，必须监听该缓存行的读操作，如果有，先将其它缓存（S状态）中该缓存行变成 I 状态（即6的流程），写入主存，自己变为S状态
5. S状态的缓存行，有写请求，走4.流程
6. S状态的缓存行，必须监听该缓存行的失效操作，如果有，自己变为I状态
7. I状态的缓存行，有读请求，必须从主存读取
   
   这边有点绕，，有时间在细看吧。

4、内存屏障

Memory Barrier （Memory Fence）

• 可见性
  • 写屏障 （sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中
  • 而读屏障 （lfence）保证在改屏障之后，对共享变量的读取，加载的是主存中最新数据
• 有序性
  • 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
  • 读屏障会确保指令重排序时，不会将读屏障之后的代码写在读屏障之前
    

4、同步模式之Balking模式

1、定义

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

2、实现

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

public class BalkingSingleton {

    private BalkingSingleton(){}

    public static BalkingSingleton INSTANCE = null;

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

}

对比一下保护性暂停模式：保护性暂停用在一个线程等待另一个线程的执行结果，当条件不满足时线程等待

5、有序性

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

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

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

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

也可以是

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

这种特性称之为【指令重排】，多线程下【指令重排】会影响正确性。为什么要有指令重排这项优化，从CPU执行指令的原理来了解吧。

原理之指令并行

1、名词

Clock Cycle Time

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

例如，运行一条加法指令一般需要一个时钟周期

CPI

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

IPC

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

CPU执行时间

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

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

2、鱼罐头的故事

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

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

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

即是只有一个工人，最理想的情况：他能够在10分钟内做好这五件事，因为对第一条鱼的真空封罐，不影响第二条鱼的杀菌出锅

3、指令重排序优化

事实上，现代处理器会设计为一个时钟周期完成执行一条执行时间最长的CPU指令。为什么这么做呢？可以想到指令还可以再划分为一个个更小的阶段，例如，没跳指令可以分为 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回 这个五个阶段

术语参考

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

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

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

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

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

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

参考
Scoreboarding and the Tomasulo algorithm (which is similar to scoreboarding but makes use of
register renaming) are two of the most common techniques for implementing out-of-order execution
and instruction-level parallelism.

4、支持流水线的处理器

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

提示
奔腾四支持高达35级流水线，但由于功耗太高被废弃

5、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; 
}

I_Result是一个对象，有一个属性r1用来保存结果，问，可能有几种结果？

有同学这么分析

情况1：线程1先执行，这是ready = false，所以进入else分支结果为1

情况2：线程2先执行，num=2，单没来得及执行ready = true，还是进入else分支，结果为1

情况3：线程2执行到ready=true，线程1执行，这回进入if分支，结果为4（因为num已经执行过了）

但是实际情况的结果还有可能为0！

这种情况下是：线程2执行ready=true，切换到线程1，进入if分支，相加为0，再切回线程2执行num = 2

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

借助Java并发压测工具jcstress：https://wiki.openjdk.java.net/display/CodeTools/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 

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

*** INTERESTING tests 
 Some interesting behaviors observed. This is for the plain curiosity. 
 2 matching test results. 
 [OK] test.ConcurrencyTest 
 (JVM args: [-XX:-TieredCompilation]) 
 Observed state Occurrences Expectation Interpretation 
 0 1,729 ACCEPTABLE_INTERESTING !!!! 
 1 42,617,915 ACCEPTABLE ok 
 4 5,146,627 ACCEPTABLE ok 
 [OK] test.ConcurrencyTest 
 (JVM args: []) 
 Observed state Occurrences Expectation Interpretation 
 0 1,652 ACCEPTABLE_INTERESTING !!!! 
 1 46,460,657 ACCEPTABLE ok 
 4 4,571,072 ACCEPTABLE ok 

可以看到，出现结果为0情况有1,729次，虽然结果较少，但还是出现了。

解决办法

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;
	}
}

结果

*** INTERESTING tests 
 Some interesting behaviors observed. This is for the plain curiosity. 
 0 matching test results. 

原理之volatile

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

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

1、如何保证可见性

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

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

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

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

2、如何保证有序性

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

•   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;
   	}
   }
  

还是那句话，不能解决指令交错：

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

3、double-checked locking问题

以著名的double-checked locking单例模式为例

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()才使用synchronized加锁，后续使用时无需加锁
• 有隐含的但很关键的一点：第一个if使用了INSTANCE变量，是在同步代码块外

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

 0 getstatic #2 <termination/Singleton.INSTANCE : Ltermination/Singleton;>
 3 ifnonnull 37 (+34)
 6 ldc #3 <termination/Singleton>
 8 dup
 9 astore_0
10 monitorenter
11 getstatic #2 <termination/Singleton.INSTANCE : Ltermination/Singleton;>
14 ifnonnull 27 (+13)
17 new #3 <termination/Singleton>
20 dup
21 invokespecial #4 <termination/Singleton.<init> : ()V>
24 putstatic #2 <termination/Singleton.INSTANCE : Ltermination/Singleton;>
27 aload_0
28 monitorexit
29 goto 37 (+8)
32 astore_1
33 aload_0
34 monitorexit
35 aload_1
36 athrow
37 getstatic #2 <termination/Singleton.INSTANCE : Ltermination/Singleton;>
40 areturn

其中

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

也许JVM会优化成：先执行24，在执行21，如果两个线程t1，t2按如下时间序执行

关键在于 0 getstatic这行代码在monitor控制之外（所以多线程可能有问题），他就像之前不守规则的人，可以越过monitor读取INSTANCE的值

这是t1还没有完全将构造方法执行完毕，如果在构造方法中药执行很多初始化操作，那么t2拿到的将是一个未初始化完毕的单例

对INSTANCE使用volatile修饰即可，可以禁用指令重排，但要注意在JDK5以上版本的volatile才会真正生效

4、double-checked locking解决

public final class Singleton {

    private Singleton() {
    }

    private static volatile Singleton INSTANCE = null;

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

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

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

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

• 可见性
  • 写屏障（sfence）保证在该屏障之前的t1对共享变量的改动，都同步到主存中
  • 而读屏障（lfence）保证在该屏障之后t2对共享变量的读取，加载的是主存中最新的数据
• 有序性
  • 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
  • 读屏障会确保指令重排序时，不会讲读屏障之后的代码排在读屏障之前
• 更低层是读写变量时使用lock指令来保证多核CPU之间的可见性和有序性

happens-before

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

• 线程解锁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();

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

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.interrupt或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);
}

• 对变量默认值（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();

习题

balking模式练习题

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

public class TestVolatile {
 	volatile boolean initialized = false;
 	void init() {
 		if (initialized) { 
 			return;
 		} 
 		doInit();
 		initialized = true;
 	}
 	private void doInit() {
 	}
} 

没锁，不能保证代码执行的原子性

线程安全单例习题

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

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

习题略

6、本章小结

本章重点讲解了JMM的

• 可见性-由JVM缓存优化引起
• 有序性-由JVM指令重排序优化引起
• happens-before问题
• 原理
  • CPU 指令并行
  • volatile
• 模式
  • 两阶段终止volatile改进
  • 同步模式之balking