🗃️

Java内存模型

深入理解java内存模型

基本概念

基本概念

指令级并行原理

指令级并行原理

可见性

缓存导致的可见性问题

在单核时代,所有的线程都是在一颗 CPU 上执行,CPU 缓存与内存的数据一致性容易解 决。因为所有线程都是操作同一个 CPU 的缓存,一个线程对缓存的写,对另外一个线程来 说一定是可见的。例如在下面的图中,线程 A 和线程 B 都是操作同一个 CPU 里面的缓 存,所以线程 A 更新了变量 V 的值,那么线程 B 之后再访问变量 V,得到的一定是 V 的 最新值(线程 A 写过的值)。
notion image
一个线程对共享变量的修改,另外一个线程能够立刻看到,我们称为可见性。
多核时代,每颗 CPU 都有自己的缓存,这时 CPU 缓存与内存的数据一致性就没那么容易 解决了,当多个线程在不同的 CPU 上执行时,这些线程操作的是不同的 CPU 缓存。比如 下图中,线程 A 操作的是 CPU-1 上的缓存,而线程 B 操作的是 CPU-2 上的缓存,很明 显,这个时候线程 A 对变量 V 的操作对于线程 B 而言就不具备可见性了。这个就属于硬件程序员给软件程序员挖的“坑”。
notion image
 
例 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(true){ if(!run) { break; } } }); t.start(); sleep(1); run = false; // 线程t不会如预想的停下来 } }
初始状态, t 线程刚开始从主内存读取了 run 的值到工作内存。
notion image
因为 t 线程要频繁从主内存中读取 run 的值,JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中, 减少对主存中 run 的访问,提高效率
notion image
1 秒之后,main 线程修改了 run 的值,并同步至主存,而 t 是从自己工作内存中的高速缓存中读取这个变量 的值,结果永远是旧值
解决方法
  • volatile关键字
    • 它可以用来修饰成员变量和静态成员变量,他可以避免线程从自己的工作缓存中查找变量的值,必须到主存中获取它的值,线程操作 volatile 变量都是直接操作主存
  • synchronized
    • synchronized 语句块既可以保证代码块的原子性,也同时保证代码块内变量的可见性。但缺点是 synchronized 是属于重量级操作,性能相对更低
      • notion image
       
 

volatile关键字

java内存模型对volatile关键字专门定义了一些特殊的访问规则
volatile作用
  1. 保证此变量对所有线程的可见性:这里的可见性是指当一条线程修改了这个变量的值,新值对于其他线程来说是可以立即得知的(使用前先刷新)
  1. 禁止指令重排序优化,通过在本地代码中插入许多的内存屏障指令来保证处理器不发生乱序执行
  1. 无法保证原子性:但是java里面的运算并非原子操作,导致volatile变量的运算在并发下一样是不安全的
例子
public class Class1 { public static volatile int race = 0; public static void increase() { race++; } private static final int THREADS_COUNT = 20; public static void main(String[] args) { Thread[] threads = new Thread[THREADS_COUNT]; for (int i = 0; i < threads.length; i++) { threads[i] = new Thread(new Runnable() { public void run() { for (int j = 0; j < 10000; j++) { increase(); } } }); threads[i].start(); } while (Thread.activeCount() > 1) { Thread.yield(); System.out.println(race); } } }
每次输出的结果都是一个小于200000的数字且每次都不一致,因为race++并不是一个原子操作
反编译race++
0 getstatic #2 <com/google/it/Class1.race>//获取静态变量值 3 iconst_1//准备常量1 4 iadd//自增 5 putstatic #2 <com/google/it/Class1.race>//将修改后的值存入静态变量 8 return
当getstatic指令把race的值取出来的时候,volatile关键字保证了race的值是正确的,但是在执行iconst1,iadd这些指令时候,其他线程可能已经把race的值加大了,而在操作栈顶的值就变成了过期的数据,所以putstatic指令以后就可能把较小的值同步回主内存
 

有序性

as if serial 语义

as if serial 语义的意思指:不管怎么重排序( 编译器和处理器 为了提高并行度),(单线程)程序的执行结果不能被改变。编译器 runtime 和处理器都必须遵守as if serial 语义。
为了遵守as if serial 语义, 编译器和处理器不会对 存在 数据依赖关系的操作做重排序
因为这种重排序会改变执行结果,因为这种重排序会改变执行结果。但是,如果操作之间如果操作之间不存在数据依赖关系,这些操作就可能被被编译
器和处理器理器重排序。重排序。为了具体说明,请看下面计算圆面积的代码示例:
double pi = A double r = B double area = pi * r * r; C
上面三个操作的数据依赖关系如下图所示:
notion image
 
如上图所示,A 和 C 之间存在数据依赖关系,同时 B 和 C 之间也存在数据依赖关系。因此 在最终执行的指令序列中, C 不能被重排序到 A 和 B 的前面( C 排到 A 和B 的前面,程序的结果将会被改变)。
但 A 和 B 之间没有 数据依赖关系 ,编译器和处理器可以 重排序 A 和 B 之间的 执行 顺序。下图是该程序的两种执行顺序:
notion image
 

指令重排序验证及解决

JVM 会在不影响正确性的前提下,调整语句的执行顺序
static int i; static int j; // 在某个线程内执行如下赋值操作 i = ...; j = ...;
可以看到,至于是先执行 i 还是 先执行 j ,对最终的结果不会产生影响。所以,上面代码真正执行时,既可以是
i = ...; j = ...;
也可以是
j = ...; i = ...;
这种特性称之为指令重排,多线程下指令重排会影响正确性。为什么要有重排指令这项优化呢?从 CPU 执行指令的原理来理解
借助 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
@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 installjava -jar target/jcstress.jar
*** INTERESTING tests Some interesting behaviors observed. This is for the plain curiosity. 2 matching test results. [OK] cn.itcast.ConcurrencyTest (JVM args: [-XX:-TieredCompilation]) Observed state Occurrences Expectation Interpretation 0 34,056 ACCEPTABLE_INTERESTING !!!! 1 182,996,401 ACCEPTABLE ok 4 164,001,204 ACCEPTABLE ok [OK] cn.itcast.ConcurrencyTest (JVM args: []) Observed state Occurrences Expectation Interpretation 0 18,814 ACCEPTABLE_INTERESTING !!!! 1 148,615,327 ACCEPTABLE ok 4 146,086,140 ACCEPTABLE ok
出现0的结果为3万和1万8,证明num=2 被重排序到 ready = true之后执行;
volatile 修饰的变量,可以禁用指令重排,上述代码修改volatile boolean ready = false;
*** INTERESTING tests Some interesting behaviors observed. This is for the plain curiosity. 0 matching test results.

volatile原理

volatile 的底层实现原理是内存屏障,Memory Barrier(Memory Fence)
  • 对 volatile 变量的写指令后会加入写屏障
  • 对 volatile 变量的读指令前会加入读屏障

保证可见性

写屏障(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; } }
notion image

何保证有序性

  1. 写屏障会确保指令重排序时,不会将写屏障之前的代码排在写屏障之后
  1. 读屏障会确保指令重排序时,不会将读屏障之后的代码排在读屏障之前
 
写屏障仅仅是保证之后的读能够读到最新的结果,但不能保证读跑到它前面去 而有序性的保证也只是保证了本线程内相关代码不被重排序
两个线程对volatile 变量进行读写
notion image
 

双重检查锁(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; } }
 
以上的实现特点是:
  • 懒惰实例化 首次使用 getInstance() 才使用
  • synchronized 加锁,后续使用时无需加锁
  • 有隐含的,但很关键的一点:第一个 if 使用了 INSTANCE 变量,是在同步块之外
但在多线程环境下,上面的代码是有问题的,getInstance 方法对应的字节码为:
 
0: getstatic 3: ifnonnull 6: ldc 8: dup 9: astore_0 10: monitorenter 11: getstatic 14: ifnonnull 17: new 20: dup 21: invokespecial #4 24: putstatic #2 27: aload_0 28: monitorexit 29: goto 32: astore_1 33: aload_0 34: monitorexit 35: aload_1 36: athrow 37: getstatic 40: areturn
 
其中
  • 17 表示创建对象,将对象引用入栈 // new Singleton
  • 20 表示复制一份对象引用 // 引用地址
  • 21 表示利用一个对象引用,调用构造方法
  • 24 表示利用一个对象引用,赋值给 static INSTANCE 也许 jvm 会优化为:先执行 24,再执行 21。如果两个线程 t1,t2 按如下时间序列执行
notion image
 
关键在于 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) { // 也许有其它线程已经创建实例,所以再判断一次 if (INSTANCE == null) { INSTANCE = new (); } } } return INSTANCE; } }
 
读写 volatile 变量时会加入内存屏障(Memory Barrier(Memory Fence)),保证下面 两点
  • 可见性
    • 写屏障(sfence)保证在该屏障之前的 t1 对共享变量的改动,都同步到主存当中
    • 而读屏障(lfence)保证在该屏障之后 t2 对共享变量的读取,加载的是主存中最新数据
  • 有序性
    • 写屏障会确保指令重排序时,不会将写屏障之前的代码排在写屏障之后
    • 读屏障会确保指令重排序时,不会将读屏障之后的代码排在读屏障之前
    • 更底层是读写变量时使用 lock 指令来保证多核 CPU 之间的可见性与有序性
       
       
       

happens-before规则

happens-before规则

线程安全单例

例1
// 问题1:为什么加 final // 问题2:如果实现了序列化接口, 还要做什么来防止反序列化破坏单例 public final class Singleton implements Serializable { // 问题3:为什么设置为私有? 是否能防止反射创建新的实例? private Singleton() { } // 问题4:这样初始化是否能保证单例对象创建时的线程安全? private static final Singleton INSTANCE = new Singleton(); // 问题5:为什么提供静态方法而不是直接将 INSTANCE 设置为 public, 说出你知道的理由 public static Singleton getInstance() { return INSTANCE; } public Object readResolve() { return INSTANCE; } }
  1. 加 final 防止子类重写父类方法破化单例结构
  1. 反序列化会破坏单例,解决方法,写readResolve()返回单例 https://www.cnblogs.com/kexianting/p/8977990.html
  1. 设置构造器私有,防止其他类里通过new 创建对象 ,并不能防止反射创建新对象
  1. 能够保证线程安全,类初始化的时候创建一次对象,
  1. 使用方法可以增强对单例创建的控制,提供更好的封装性和拓展性,比如改为懒汉式单例
 
例2 枚举单例
// 问题1:枚举单例是如何限制实例个数的 // 问题2:枚举单例在创建时是否有并发问题 // 问题3:枚举单例能否被反射破坏单例 // 问题4:枚举单例能否被反序列化破坏单例 // 问题5:枚举单例属于懒汉式还是饿汉式 // 问题6:枚举单例如果希望加入一些单例创建时的初始化逻辑该如何做 enum Singleton { INSTANCE; }
 
反编译
// class version 52.0 (52) // access flags 0x4030 // signature Ljava/lang/Enum<Lcn/itcast/test/Singleton;>; // declaration: cn/itcast/test/Singleton extends java.lang.Enum<cn.itcast.test.Singleton> final enum cn/itcast/test/Singleton extends java/lang/Enum { // compiled from: Singleton.java // access flags 0x4019 public final static enum Lcn/itcast/test/Singleton; INSTANCE // access flags 0x101A private final static synthetic [Lcn/itcast/test/Singleton; $VALUES // access flags 0x9 public static values()[Lcn/itcast/test/Singleton; L0 LINENUMBER 3 L0 GETSTATIC cn/itcast/test/Singleton.$VALUES : [Lcn/itcast/test/Singleton; INVOKEVIRTUAL [Lcn/itcast/test/Singleton;.clone ()Ljava/lang/Object; CHECKCAST [Lcn/itcast/test/Singleton; ARETURN MAXSTACK = 1 MAXLOCALS = 0 // access flags 0x9 public static valueOf(Ljava/lang/String;)Lcn/itcast/test/Singleton; L0 LINENUMBER 3 L0 LDC Lcn/itcast/test/Singleton;.class ALOAD 0 INVOKESTATIC java/lang/Enum.valueOf (Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum; CHECKCAST cn/itcast/test/Singleton ARETURN L1 LOCALVARIABLE name Ljava/lang/String; L0 L1 0 MAXSTACK = 2 MAXLOCALS = 1 // access flags 0x2 // signature ()V // declaration: void <init>() private <init>(Ljava/lang/String;I)V L0 LINENUMBER 3 L0 ALOAD 0 ALOAD 1 ILOAD 2 INVOKESPECIAL java/lang/Enum.<init> (Ljava/lang/String;I)V RETURN L1 LOCALVARIABLE this Lcn/itcast/test/Singleton; L0 L1 0 MAXSTACK = 3 MAXLOCALS = 3 // access flags 0x8 static <clinit>()V L0 LINENUMBER 4 L0 NEW cn/itcast/test/Singleton DUP LDC "INSTANCE" ICONST_0 INVOKESPECIAL cn/itcast/test/Singleton.<init> (Ljava/lang/String;I)V PUTSTATIC cn/itcast/test/Singleton.INSTANCE : Lcn/itcast/test/Singleton; L1 LINENUMBER 3 L1 ICONST_1 ANEWARRAY cn/itcast/test/Singleton DUP ICONST_0 GETSTATIC cn/itcast/test/Singleton.INSTANCE : Lcn/itcast/test/Singleton; AASTORE PUTSTATIC cn/itcast/test/Singleton.$VALUES : [Lcn/itcast/test/Singleton; RETURN MAXSTACK = 4 MAXLOCALS = 0 }
 
  1. 字节码层面:枚举的实例,其实静态成员变量,所以一个成员对于一个实例
  1. 枚举单例在创建时没有线程安全问题,类加载阶段创建
  1. 枚举单例不能被反射破坏单例
    1. 主要是因为Construct类中的newInstance方法的一个判断条件
       
      if ((this.clazz.getModifiers() & 16384) != 0) { throw new IllegalArgumentException("Cannot reflectively create enum objects"); }
      如果是枚举类型,就会抛出异常,因此只有枚举才能避免被反射破坏 反射在通过newInstance创建对象时,会检查该类是否ENUM修饰,如果是则抛出异常,反射失败
       
      public T newInstance(Object... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { if (!this.override) { Class<?> caller = Reflection.getCallerClass(); this.checkAccess(caller, this.clazz, this.clazz, this.modifiers); } if ((this.clazz.getModifiers() & 16384) != 0) { throw new IllegalArgumentException("Cannot reflectively create enum objects"); } else { ConstructorAccessor ca = this.constructorAccessor; if (ca == null) { ca = this.acquireConstructorAccessor(); } T inst = ca.newInstance(initargs); return inst; } }
       
  1. 枚举单例不能被反序列化破坏单例 https://stackoverflow.com/questions/30671534/why-enum-singleton-are-serialization-safe
  1. 枚举单例属于恶汉式
  1. 通过提供私有构造方法可以加入一些单例创建时的初始化逻辑
 
例3
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; } }
锁的粒度比较粗,每次获取实例都需要加锁解锁
 
例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; // t2 } INSTANCE = new Singleton(); return INSTANCE; } } }
 
例5
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; } }
线程安全,懒汉式