JUC笔记(四) --- 内存共享模型

4.内存共享模型

4.1Java内存模型

JMM 即 Java Memory Model，它定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、

CPU 指令优化等。

JMM 体现在以下几个方面

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

4.2可见性

退不出的循环

static boolean run = true;
public static void main(String[] args) throws InterruptedException {
 Thread t = new Thread(()->{
 while(run){
 // ....
 }
 });
 t.start();
 sleep(1);
 run = false; // 线程t不会如预想的停下来
}
1
2
3
4
5
6
7
8
9
10
11

为什么线程t不会直接停止？

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

• 因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中，

减少对主存中 run 的访问，提高效率

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

  的值，结果永远是旧值

  

4.3解决方法：volatile

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

它的值，线程操作 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
1
2
3
4
5
6

4.4可见性问题

两个线程一个 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
1
2
3
4
5
6
7
8
9

注意 synchronized 语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性。但缺点是

synchronized 是属于重量级操作，性能相对更低

如果在前面示例的死循环中加入 System.out.println() 会发现即使不加 volatile 修饰符，线程 t 也能正确看到

对 run 变量的修改了，想一想为什么？

A：从System.out.println 从内存中读取变量

synchronized如何保证可见性：

我们都知道sychronized底层是通过monitorenter的指令来进行加锁的、通过monitorexit指令来释放锁的。

但是很多人都不知道的一点是，monitorenter指令其实还具有Load屏障的作用。

也就是通过monitorenter指令之后，synchronized内部的共享变量，每次读取数据的时候被强制从主内存读取最新的数据。

同样的道理monitorexit指令也具有Store屏障的作用，也就是让synchronized代码块内的共享变量，如果数据有变更的，强制刷新回主内存。

这样通过这种方式，数据修改之后立即刷新回主内存，其他线程进入synchronized代码块后，使用共享变量的时候强制读取主内存的数据，上一个线程对共享变量的变更操作，它就能立即看到了。

4.5CPU缓存结构原理（计组内容 可跳）

CPU缓存结构

速度比较**（计组内容）：**

缓存如何存取可以自己查资料，我简述一下

通过将内存单元分组 缓存上会记录数据的组位置以及组内位置，例如

000 1 1 是第一组

000 是组内位置 有效位 1 是这个缓存记录是否还有效 缓存过期策略详见资料

CPU缓存读

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

CPU 缓存一致性

MESI 协议

1. E、S、M 状态的缓存行都可以满足 CPU 的读请求

2. E 状态的缓存行，有写请求，会将状态改为 M，这时并不触发向主存的写

3. E 状态的缓存行，必须监听该缓存行的读操作，如果有，要变为 S 状态

4. 

5. M 状态的缓存行，必须监听该缓存行的读操作，如果有，先将其它缓存（S 状态）中该缓存行变成 I 状态（即6.的流程)，写入主存，自己变为 S 状态

6. S 状态的缓存行，有写请求，走 4. 的流程

7. S 状态的缓存行，必须监听该缓存行的失效操作，如果有，自己变为 I 状态

8. I 状态的缓存行，有读请求，必须从主存读取

内存屏障

• 可见性

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

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

• 有序性

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

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

写屏障之前指令排序以及 变量改动都是“正常”的

读屏障之后指令排序以及 变量改动都是“正常”的

4.6有序性

如果在一个线程观察另一个线程，所有操作都是无序的指的是 “指令重排序” 和 “工作内存与主内存同步延迟” 现象

思考：

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


//  指令会先执行i = ... 还是 j = ... 
//  事实上都有可能
1
2
3
4
5
6
7
8
9

原理：指令级并行

• 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执行时间=指令数\ast CPI\ast ClockCycleTime$$

指令重排序优化

事实上，现代处理器会设计为一个时钟周期完成一条执行时间最长的 CPU 指令。为什么这么做呢？可以想到指令

还可以再划分成一个个更小的阶段，例如，每条指令都可以分为： 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据

写回 这 5 个阶段

• instruction fetch (IF)

• instruction decode (ID)

• execute (EX)

• memory access (MEM)

• register write back (WB)

在不改变程序结果的前提下，这些指令的各个阶段可以通过重排序和组合来实现指令级并行

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

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

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

支持流水线的处理器

现代 CPU 支持多级指令流水线，例如支持同时执行 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回 的处理

器，就可以称之为五级指令流水线。这时 CPU 可以在一个时钟周期内，同时运行五条指令的不同阶段（相当于一

条执行时间最长的复杂指令），IPC = 1，本质上，流水线技术并不能缩短单条指令的执行时间，但它变相地提高了

指令地吞吐率。

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15

out： 0 1 4 … 出现多种情况

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

指令重排

首先说一下什么是指令重排，指令重排是指JVM在编译Java代码的时候，或者CPU在执行JVM字节码的时候，对现有的指令顺序进行重新排序。指令重排的目的是为了在不改变程序执行结果的前提下，优化程序的运行效率。需要注意的是，这里所说的不改变执行结果，指的是不改变单线程下的程序执行结果，即必须遵守as-if-serial语义（as-if-serial语义：不管怎么重排序（编译器和处理器为了提高并行度），（单线程）程序的执行结果不能被改变）

借助 java 并发压测工具 jcstress

out:

*** 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

解决方法：volatile

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

重试上一次代码，ready 改为 volatile 修饰

结果：

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

4.7volatile原理（**）

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

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

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

public void actor1(I_Result r) {
 // 读屏障
 // ready 是 volatile 读取值带读屏障
 if(ready) {
 r.r1 = num + num;
 } else {
 r.r1 = 1;
 }
}
public void actor2(I_Result r) {
 num = 2;
 ready = true; // ready 是 volatile 赋值带写屏障
 // 写屏障
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

如何保证可见性

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

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

如何保证有序性

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

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

• 写屏障仅仅是保证之后的读能够读到最新的结果，但不能保证读跑到它前面去

• 而有序性的保证也只是保证了本线程内相关代码不被重排序

double-checked locking 问题

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

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;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

以上的实现特点是：

• 懒惰实例化

• 首次使用 getInstance() 才使用 synchronized 加锁，后续使用时无需加锁

• 有隐含的，但很关键的一点：第一个 if 使用了 INSTANCE 变量，是在同步块之外但在多线程环境下，上面的代码是有问题的，getInstance 方法对应的字节码为：

  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;
  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
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23

  • 17 表示创建对象，将对象引用入栈 // new Singleton

  • 20 表示复制一份对象引用 // 引用地址

  • 21 表示利用一个对象引用，调用构造方法

  • 24 表示利用一个对象引用，赋值给 static INSTANCE

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

  

也就是t1线程将singleton尚未完全初始化，而已经将引用值赋给singleton，t2直接获取到了未初始化的singleton

关键在于 0: getstatic 这行代码在 monitor 控制之外，它就像之前举例中不守规则的人，可以越过 monitor 读取

INSTANCE 变量的值

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

始化完毕的单例

对 INSTANCE 使用 volatile 修饰即可，可以禁用指令重排，但要注意在 JDK 5 以上的版本的 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;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// -------------------------------------> 加入对 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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

两点：

• 可见性

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

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

• 有序性

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

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

volatile与synchronized

synchronized 保证： 原子性、有序性和可见性

volatile 保证： 有序性、可见性

注意：这两个有序的意思是不一样的。

synchronized 是不能保证指令重排的

• synchronized 的有序性：是持有相同锁的两个同步块只能串行的进入，即被加锁的内容要按照顺序被多个线程执行，但是其内部的同步代码还是会发生重排序，使块与块之间有序可见。
• volatile的有序性：是通过插入内存屏障来保证指令按照顺序执行。不会存在后面的指令跑到前面的指令之前来执行。是保证编译器优化的时候不会让指令乱序。

ynchronized保证有序性：和volatile一样

是持有相同锁的两个同步块只能串行的进入，即被加锁的内容要按照顺序被多个线程执行，但是其内部的同步代码还是会发生重排序，使块与块之间有序可见。

保证的是同步代码块中的有序性

StoreStore屏障：禁止StoreStore屏障的前后Store写操作重排

LoadLoad屏障：禁止LoadLoad屏障的前后Load读操作进行重排

LoadStore屏障：禁止LoadStore屏障的前面Load读操作跟LoadStore屏障后面的Store写操作重排

StoreLoad屏障：禁止LoadStore屏障前面的Store写操作跟后面的Load/Store 读写操作

也是通过monitorenter、monitorexit指令嵌入上面的内存屏障；monitorenter、monitorexit这两条指令其实就相当于复合指令，既具有加锁、释放锁的功能，同时也具有内存屏障的功能

但是无法禁止指令重排

4.8happens-before

happens-before 规定了对共享变量的写操作对其它线程的读操作可见，它是可见性与有序性的一套规则总结，抛

开以下 happens-before 规则，JMM 并不能保证一个线程对共享变量的写，对于其它线程对该共享变量的读可见

通过volatile进行解决该问题

4.9单例模式

• 推荐：是线程安全的，当第一次使用这个类时会加载Instance，而JVM加载这个类初始化这个实例变量时是保证了线程的安全性的

public final class Singleton {
 private Singleton() { }
 // 问题1：属于懒汉式还是饿汉式
 private static class LazyHolder {
 static final Singleton INSTANCE = new Singleton();
 }
 // 问题2：在创建时是否有并发问题
 public static Singleton getInstance() {
 return LazyHolder.INSTANCE;
 }
}
1
2
3
4
5
6
7
8
9
10
11

• 将锁加在类上，保证有序性和可见性，不会出现线程安全问题。缺点：效率低

  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;
   }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

• 推荐：性能好，做了两次非空判断是为了防止线程安全问题

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) { // t2 
                return INSTANCE;
            }
            INSTANCE = new Singleton();
            return INSTANCE;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20