JUC学习笔记 3-JMM、Volatile、单例模式

JMM

谈谈对 volatile 的理解

Volatile是java虚拟机提供轻量级的同步机制

1. 保证可见性
2. 不保证原子性
3. 禁止指令重排

什么是JMM

JMM：Java内存模型，不存在的东西、概念/模型

关于JMM的一些同步约定：

1. 线程解锁前，必须把共享变量立刻刷回主存。
2. 线程加锁前，必须读取主存中的最新值到工作内存中！
3. 加锁和解锁是同一把锁

8种操作
线程 工作内存、主内存

内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）

• lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
• unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
• read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
• load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
• use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
• assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
• store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
• write 　（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中

JMM对这八种指令的使用，制定了如下规则：

• 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
• 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
• 不允许一个线程将没有assign的数据从工作内存同步回主内存
• 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作
• 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
• 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
• 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
• 对一个变量进行unlock操作之前，必须把此变量同步回主内存

参考：java内存模型JMM理解整理

volatile

1. 保证可见性
2. 不保证原子性（如何不用synchronized和lock如何保证原子性呢？->使用原子类）
3. 禁止指令重排
   
   内存屏障。cpu指令。作用：

• 保证特定的操作的执行顺序
• 可以保证某些变量的内存可见性
  

原子类

单例模式

饿汉式

// 饿汉式单例 ,单例模式首先构造器私有化
public class Hungry {
    private Hungry(){}
    private final static Hungry hungry = new Hungry();
    public static Hungry getInstance(){
        return hungry;
    }
}

懒汉式

// 懒汉式单例
public class LazyMan {
    private static boolean flag = false;
    private LazyMan(){
        synchronized (LazyMan.class){
            if (flag == false){
                flag = true;
            }else{
                throw new RuntimeException("不要试图通过反射获取实例");
            }
        }
        System.out.println("###");
    }
    private static volatile LazyMan lazyMan;
    //双重检测锁模式的 懒汉式单例 DCL懒汉式
    public static LazyMan getInstance(){
        if (lazyMan ==null){
            synchronized (LazyMan.class){
                if (lazyMan == null) {
                    lazyMan = new LazyMan(); //不是一个原子性操作
                    /**
                     * 1、分配内存空间
                     * 2、执行构造方法，初始化对象
                     * 3、把这个对象指向这个空间
                     * 123
                     * 132  A
                     *      B //此时lazyMan还没有完成构造，但不为null
                     * */
                }
            }
        }
        return lazyMan;
    }

    // 反射
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance1 = declaredConstructor.newInstance();
        LazyMan instance = LazyMan.getInstance();
        System.out.println(instance);
        System.out.println(instance1);
    }
}

静态内部类单例

public class Holder {
    private Holder(){}
    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }
    public static class InnerClass{
        private static final Holder HOLDER = new Holder();
    }
}

单例模式不安全，因为有反射–>枚举

newInstence 不允许利用反射创建Enum实例


Enum用反射报错，但并非是上面所预计的错误

javap -p 反编译 查找原因

但反编译出的还是欺骗了我们，报错没有空构造器，但反编译出来的确实有，遂使用jad反编译，才发现提供的是有参构造器： jad -sjava EnumSingleton.class

出现预计结果