9.共享模型之内存

wuhming 收录于 juc

2024-02-04 2024-02-04 约 342 字预计阅读 2 分钟

共享模型之内存

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

JMM 体现在以下几个方面

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

可见性

问题

public class Test1 {
    static boolean run = true;

    public static void main(String[] args) throws InterruptedException {

        Thread t = new Thread(()->{
            while(run){
                // ....
            }
        });
        t.start();

        SleepUtil.sleep(1);
        // 线程t不会如预想的停下来
        run = false;
    }
}

在睡眠1s后没有停止

分析

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

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

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

解决方案：关键字 volatile

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

有序性

指令重排序

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

static int i;
static int j;

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

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

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

也可以是

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

这种特性称之为『指令重排』，多线程下『指令重排』会影响正确性,volatile 修饰的变量，可以禁用指令重排

运用-balking 模式

单例模式有很多实现方法，饿汉、懒汉、静态内部类、枚举类

饿汉式：类加载就会导致该单实例对象被创建

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

实现一

public final class Singleton implements Serializable {
    
    private Singleton() {}

    private static final Singleton INSTANCE = new Singleton();
    
    public static Singleton getInstance() {
        return INSTANCE;
    }
    public Object readResolve() {
        return INSTANCE;
    }
}

类通过final修饰：是为了防止子类继承，增加方法破坏类的单例性
如果该类实现了序列化接口，还需要增加 public Object readResolve() 方法来防止反序列化破坏单例
无参构造函数设为私有，是为了防止通过构造器实例化对象，从而破坏了类的单例性
private static final Singleton INSTANCE = new Singleton(); 通过static关键字修饰后，能保证线程安全，因为静态成员变量初始化操作实在类加载的时候完成的，而类加载时由JVM保证线程安全
通过 public static Singleton getInstance()静态方法将实例返回可以提供更好的封装性，可以内部实现懒惰的初始化，还可以对创建单例对象时实现更多的初始化控制，还可以提供泛型的支持

实现二

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

虽然能保证线程安全，但是效率低，因为每次获取实例都需要加锁，而 synchronized 本身就是重量级锁

实现三：DCL

public final class Singleton {
    private Singleton() { }
    
    // 问题1：解释为什么要加 volatile ?
    private static volatile Singleton INSTANCE = null;
    
    // 问题2：对比实现2, 说出这样做的意义 
    public static Singleton getInstance() {
        if (INSTANCE != null) { 
            return INSTANCE;
        }
        synchronized (Singleton.class) { 
            // 问题3：为什么还要在这里加为空判断, 之前不是判断过了吗
            if (INSTANCE != null) { // t2 
                return INSTANCE;
            }
            INSTANCE = new Singleton(); 
            return INSTANCE;
        } 
    }
}

private static volatile Singleton INSTANCE = null; 这里加上 volatile 关键字是为了确保指令的有序性，如果不加，在 17行（ INSTANCE = new Singleton(); ）可能会发生指令重排序从而导致 先赋值后创建对象，而创建对象时真正的构造方法还未执行完，这是已经将引用赋值完成，其他线程来的时候返回的是一个未初始化完成的对象实例。
对比实现二，缩小了临界区代码块内容，减少了锁时间，提高了并发量
如果对个线程都执行到了 synchronized (Singleton.class) 这一行，虽然只有一个线程能继续执行，但是这个线程执行完成后，其他线程竞争到锁以后又会继续执行，如果不判空，那么就是再实例化一次

实现四（推荐）无锁懒汉模式

public final class Singleton {
    private Singleton() { }
    
    private static class LazyHolder {
        static final Singleton INSTANCE = new Singleton();
    }
   
    public static Singleton getInstance() {
        return LazyHolder.INSTANCE;
    }
}