单例模式即代码中只有一个实例的模式

适用场景：有些场景下，有的类只能有一个对象，不能有多个

要注意：在单例模式下，要保证不能产生多个实例

1、饿汉模式

class Singleton{
    private static Singleton instance = new Singleton();

    public static Singleton getSingleton() {
        return instance;
    }

    private Singleton(){
    }
}

public class demo {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getSingleton();
        Singleton singleton2 = Singleton.getSingleton();
        System.out.println(singleton1==singleton2);
        System.out.println(singleton1.equals(singleton2));
    }
}

将构造方法设为private，使得不能自己初始化类， 只能用默认给定的类

由于是单例，所以singleton1与singleton2地址内容都是一样的，两者是同一个实例

2、 懒汉模式

（1）懒汉模式-不安全

class SingletonLazy{
    private static SingletonLazy instance = null;

    public static SingletonLazy getSingletonLazy() {
        if(instance == null){
            instance = new SingletonLazy();
        }
        return instance;
    }

    private SingletonLazy(){
    }
}

public class demo {
    public static void main(String[] args) {
        SingletonLazy singletonLazy1 = SingletonLazy.getSingletonLazy();
        SingletonLazy singletonLazy2 = SingletonLazy.getSingletonLazy();
        System.out.println(singletonLazy1 == singletonLazy2);
        System.out.println(singletonLazy1.equals(singletonLazy2));
    }
}

饿汉模式中，无论原来有没有创建instance，都会初始化一个新的instance

懒汉模式为了节约开销，会在getSingletonLazy()方法中判断instance是否是null。如果不是null，说明instance已经初始化，只须直接返回即可；如果是第一次获取，那么instance没有初始化，是null，这时初始化后再返回

（2）懒汉模式-线程安全

上面的代码存在的问题是：由于判断if(instance == null)这一步和初始化instance = new SingletonLazy()这一步是分开的，有可能会出现线程安全问题

​​​​​​​

如上图，T1和T2都各创建了一个instance实例，从而出现了两个实例，破坏了单例模式的规则

为了解决上述线程安全问题，我们在getSingletonLazy()方法中对这段代码进行加锁（静态方法代码块加锁对象用类名.class）

public static SingletonLazy getInstance() {
       synchronized (SingletonLazy.class){
                if(instance == null){
                    instance = new SingletonLazy();
                }
       }
   
       return instance;
 }

（3）空间浪费

改成加锁代码后，产生了一个新问题，那就是：每次获得instance时都要进行加锁，但是加锁本身是一项耗费空间资源的操作，这样便会大大降低代码性能

如果我们能够得知实例已经创建，那么就不用再进行加锁了，所以在加锁之前我们对instance进行一次判断

public static SingletonLazy getInstance() {
        if(instance == null){
            synchronized (SingletonLazy.class){
                if(instance == null){
                    instance = new SingletonLazy();
                }
            }
        }

        return instance;
}

注意，第一次判断和第二次判断作用并不一样：第一次是为了判断是否需要加锁；第二次是为了判断是否需要新创建实例

（4）指令重排序问题

经过两次优化，上述代码仍存在问题，那就是——指令重排序问题

 · 什么是指令重排序问题呢

当我们在new一个对象的时候，new这个过程分为三步

1.申请内存空间
2.在内存空间上构造对象 (构造方法)

3.把内存的地址,赋值给 instance 引用

这个过程可以按照123来执行，也可以按照132的顺序来执行 

在我们上述优化过的代码中，如果T1线程在new的过程中按照132的顺序来执行，那么在执行到第二步时，恰好T2第一次对instance进行判断，由于instance已经创建了实例，那么T2会直接返回这个没有构造对象的instance

如果代码中对返回的instance进行访问属性/方法等操作，程序就会报错

 · volatile

为了解决这个问题，我们使用了volatile关键字来对instance变量进行修饰

这样，在进行new操作时，就不会产生指令重排序问题

class SingletonLazy{
    private static volatile SingletonLazy instance = null;

    public static SingletonLazy getInstance() {
        if (instance == null){
            synchronized (SingletonLazy.class){
                if (instance == null){
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }
    
    private SingletonLazy(){
    }
}

volatile解决内存可见性问题