单例模式学习总结

单例模式：

1，静态的变量和静态的方法
2，私有化构造方法
volatile 关键字用于保持线程之间的可见性和防止指令重排序问题，主内存和工作内存交换时，保持原子操作的连续性，从而让变量始终看到的是自己的最新值。即线程操作的相互可见性，理解volatile作用之前我们先了解一下修改的过程
线程在jvm运行时内存分配过程：

image.png

线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存
变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，
在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。

竞态条件是指的是程序需要判断状态来做出操作，然后多线程中可能在完成操作之前就对状态作出了修改，这时候结果不是我们想要的，需要通过synchronized来同步。

比如单例模式中第一次新建时判断完状态，还未完成，另一个线程来按照空进行判断，产生两次创建。

但又出现串行化的单例，同步有比较耗时，所以采用双重检查锁，即在同步之前作一个非空判断

class Singleton {
    private static Singleton instance;
    private Singleton(){}
    public static Singleton getInstance() {
        if ( instance == null ) { //当instance不为null时，仍可能指向一个“被部分初始化的对象”
            synchronized (Singleton.class) {
                if ( instance == null ) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

“看起来”非常完美：既减少了阻塞，又避免了竞态条件。不错，但实际上仍然存在一个问题——当instance不为null时，仍可能指向一个被部分初始化的对象。
问题出在这行简单的赋值语句：

instance = new Singleton();

它并不是一个原子操作。事实上，它可以”抽象“为下面几条JVM指令：

memory = allocate();    //1：分配对象的内存空间
initInstance(memory);   //2：初始化对象
instance = memory;      //3：设置instance指向刚分配的内存地址

上面操作2依赖于操作1，但是操作3并不依赖于操作2，所以JVM可以以“优化”为目的对它们进行重排序，经过重排序后如下：

memory = allocate();    //1：分配对象的内存空间
instance = memory;      //3：设置instance指向刚分配的内存地址（此时对象还未初始化）
ctorInstance(memory);   //2：初始化对象

可以看到指令重排之后，操作 3 排在了操作 2 之前，即引用instance指向内存memory时，这段崭新的内存还没有初始化——即，引用instance指向了一个"被部分初始化的对象"。此时，如果另一个线程调用getInstance方法，由于instance已经指向了一块内存空间，从而if条件判为false，方法返回instance引用，用户得到了没有完成初始化的“半个”单例。
解决这个该问题，只需要将instance声明为volatile变量：

private static volatile Singleton instance;

对于编译器来说，发现一个最优布置来最小化插入屏障的总数几乎不可能，为此，Java内存模型采取保守策略。下面是基于保守策略的JMM内存屏障插入策略：

在每个volatile写操作的前面插入一个StoreStore屏障。

在每个volatile写操作的后面插入一个StoreLoad屏障。

在每个volatile读操作的后面插入一个LoadLoad屏障。

在每个volatile读操作的后面插入一个LoadStore屏障。

volatile和synchronized区别
1、volatile不会进行加锁操作：

volatile变量是一种稍弱的同步机制在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比synchronized关键字更轻量级的同步机制。

2、volatile变量作用类似于同步变量读写操作：

从内存可见性的角度看，写入volatile变量相当于退出同步代码块，而读取volatile变量相当于进入同步代码块。

3、volatile不如synchronized安全：

在代码中如果过度依赖volatile变量来控制状态的可见性，通常会比使用锁的代码更脆弱，也更难以理解。仅当volatile变量能简化代码的实现以及对同步策略的验证时，才应该使用它。一般来说，用同步机制会更安全些。

4、volatile无法同时保证内存可见性和原则性：

加锁机制（即同步机制）既可以确保可见性又可以确保原子性，而volatile变量只能确保可见性，原因是声明为volatile的简单变量如果当前值与该变量以前的值相关，那么volatile关键字不起作用，也就是说如下的表达式都不是原子操作：“count++”、“count = count+1”。

最后回归正题：
三种安全的单例模式：
恶汉模式

/**
 * 单例模式，饿汉模式，不管为不为空，先直接new一个出来
 */
public class SingletonImp {
    // 饿汉模式
    private static SingletonImp singletonImp = new SingletonImp();
    // 私有化（private）该类的构造函数
    private SingletonImp() {
    }

    public static SingletonImp getInstance() {
        return singletonImp;
    }

    public static void main(String[] args) {
        System.out.println(SingletonImp.getInstance());
    }
}

双重检查锁：

/**
 * SingletonImp3中每次调用getInstance都会加同步锁，而加锁是一个很耗时的过程
 * 实际上加锁只需要在第一次创建对象时
 */
public class SingletonImp4 {
    private static SingletonImp4 singletonImp4;

    private SingletonImp4() {}

    public static SingletonImp4 getInstance() {
        // 第一次创建时才加锁
        if (singletonImp4 == null) {
            synchronized (SingletonImp4.class) {
                if (singletonImp4 == null) {
                    singletonImp4 = new SingletonImp4();
                }
            }
        }

        return singletonImp4;
    }
}
public class SingletonImpl7 {
    //用volatile保证线程可见性和指令重排序
    private static volatile SingletonImpl7 singletonImp;
    private SingletonImpl7(){
    }
    public static SingletonImpl7 getInstance(){
        if (null == singletonImp){
            synchronized(SingletonImpl7.class){
                if (null == singletonImp){
                    singletonImp = new SingletonImpl7();
                }
            }
        }
        return singletonImp;
    }
}

内部类模式：

/**
 * SingletonImp5使用静态代码块，如果该类中还有其他静态方法，调用后就会执行静态代码块使得对象过早创建
 * 使用一个静态类来创建Singleton，其他静态方法只要没有调用Nested.singletonImp6就不会创建Singleton
 * 实现了需要时才创建实例对象，避免过早创建
 */
public class SingletonImp6 {
    private SingletonImp6() {}

    // 专门用于创建Singleton的静态类,加载类时，同时执行静态块，给静态变量赋值
    private static class Nested{
        private static SingletonImp6 singletonImp6;
        static {
           singletonImp6 = new SingletonImp6();
        }
    }
    //直接返回静态内部类的静态变量，实现需要时在加载
    public static SingletonImp6 getInstance() {
        return Nested.singletonImp6;
    }