Java内存模型

深入理解java内存模型

基本概念指令级并行原理可见性缓存导致的可见性问题 volatile关键字有序性 as if serial 语义指令重排序验证及解决 volatile原理保证可见性何保证有序性双重检查锁（Double-Checked Locking）happens-before规则线程安全单例

基本概念

基本概念

指令级并行原理

可见性

缓存导致的可见性问题

在单核时代，所有的线程都是在一颗 CPU 上执行，CPU 缓存与内存的数据一致性容易解决。因为所有线程都是操作同一个 CPU 的缓存，一个线程对缓存的写，对另外一个线程来说一定是可见的。例如在下面的图中，线程 A 和线程 B 都是操作同一个 CPU 里面的缓存，所以线程 A 更新了变量 V 的值，那么线程 B 之后再访问变量 V，得到的一定是 V 的最新值（线程 A 写过的值）。

一个线程对共享变量的修改，另外一个线程能够立刻看到，我们称为可见性。

多核时代，每颗 CPU 都有自己的缓存，这时 CPU 缓存与内存的数据一致性就没那么容易解决了，当多个线程在不同的 CPU 上执行时，这些线程操作的是不同的 CPU 缓存。比如下图中，线程 A 操作的是 CPU-1 上的缓存，而线程 B 操作的是 CPU-2 上的缓存，很明显，这个时候线程 A 对变量 V 的操作对于线程 B 而言就不具备可见性了。这个就属于硬件程序员给软件程序员挖的“坑”。

例 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 的值到工作内存。

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

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

解决方法

volatile关键字

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

synchronized

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

volatile关键字

java内存模型对volatile关键字专门定义了一些特殊的访问规则

volatile作用

保证此变量对所有线程的可见性:这里的可见性是指当一条线程修改了这个变量的值,新值对于其他线程来说是可以立即得知的(使用前先刷新)

禁止指令重排序优化,通过在本地代码中插入许多的内存屏障指令来保证处理器不发生乱序执行

无法保证原子性:但是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

上面三个操作的数据依赖关系如下图所示：

如上图所示，A 和 C 之间存在数据依赖关系，同时 B 和 C 之间也存在数据依赖关系。因此在最终执行的指令序列中， C 不能被重排序到 A 和 B 的前面（ C 排到 A 和B 的前面，程序的结果将会被改变）。

但 A 和 B 之间没有数据依赖关系，编译器和处理器可以重排序 A 和 B 之间的执行顺序。下图是该程序的两种执行顺序：

指令重排序验证及解决

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

何保证有序性

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

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

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

两个线程对volatile 变量进行读写

双重检查锁（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 按如下时间序列执行

关键在于 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规则

线程安全单例

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

加 final 防止子类重写父类方法破化单例结构

反序列化会破坏单例,解决方法,写readResolve()返回单例 https://www.cnblogs.com/kexianting/p/8977990.html

设置构造器私有,防止其他类里通过new 创建对象 ,并不能防止反射创建新对象

能够保证线程安全,类初始化的时候创建一次对象,

使用方法可以增强对单例创建的控制,提供更好的封装性和拓展性,比如改为懒汉式单例

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

字节码层面:枚举的实例,其实静态成员变量,所以一个成员对于一个实例

枚举单例在创建时没有线程安全问题,类加载阶段创建

枚举单例不能被反射破坏单例

主要是因为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;
        }
    }

枚举单例不能被反序列化破坏单例 https://stackoverflow.com/questions/30671534/why-enum-singleton-are-serialization-safe

枚举单例属于恶汉式

通过提供私有构造方法可以加入一些单例创建时的初始化逻辑

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

线程安全,懒汉式