单例模式的七种实现方式，你学废了吗？

单例模式

什么是单例模式,概念就不多做描述了，直接头铁冲代码…

一、饿汉式（饿鬼投胎，程序一启动就创建单例）

饿汉式单例模式，是饿汉式：程序一启动就加载
饿汉式起码能保证单例，虽然会浪费内存，但是会保证只有一个实例
饿汉式有2种写法：一种是静态常量的饿汉式
另一种是静态代码块的饿汉式

1、静态常量的饿汉式

/**
 * 静态常量的饿汉式
 * @version 1.0
 * @date 2021/1/2 21:38
 */
public class HungryLoadSingleton1 {
    @Test
    public void test(){
        Singleton instance1 = Singleton.instance;
        Singleton instance2 = Singleton.instance;
        System.out.println(instance1 == instance2);
        //输出结果是为true
    }
}
class Singleton{
    //1.1私有化构造方法，防止直接外部new一个对象
   private Singleton(){}
   //1.2 静态常量直接创建一个对象
   public static Singleton instance = new Singleton();
}

2、静态代码块饿汉式

public class HungryLoadSingleton2 {
    @Test
    public void test(){
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
    }
}
class Singleton{
    //1.1私有化构造方法，防止直接外部new一个对象
    private Singleton(){}
    //1.2 静态常量直接创建一个对象
    private static Singleton instance ;
    
    static {
        //1.3 在静态代码块种创建单例(因为静态代码块只会执行一次)
        instance = new Singleton();
    }
    //1.4提供静态方法获得单例对象
    public static Singleton getInstance(){
        return instance;
    }
}

铁子，你是否还记得静态代码块、代码块、构造方法，以及子类继承父类，创建子类对象的时候的静态代码块、代码块、构造方法的执行顺序？

二、 懒汉式（懒鬼附身，当你要用的时候才创建）

懒汉式单例一共有三种写法
（1）线程不安全
（2）线程安全
（3）双重校验模式

1、线程不安全懒汉式

/**
 * 懒加载方式，要使用的时候采取加载
 * 线程不安全的懒加载
 * @version 1.0
 * @date 2021/1/2 21:34
 */
public class LazyLoadSingleton1 {
    @Test
    public void test(){
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
    }
}

class Singleton{
    //1.1私有化构造方法，防止直接外部new一个对象
    private Singleton(){}
    //1.2 静态常量直接创建一个对象
    private static Singleton instance = null ;

    //1.3提供一个公有的静态方法，当调用该方法的时候才创建对象
    public static Singleton getInstance(){
       if(instance == null){
           instance = new Singleton();
       }
        return instance;
    }
}

存在的问题：在多线程的情况下，当有多个请求来的时候，都进行 if(instance == null)的判断，但是没有来得及创建对象，所以条件都是满足的，进而会创建多个实例

2、线程安全懒汉式

由于上面线程不安全，引申出底下这种写法

/**
 * 懒加载方式，要使用的时候采取加载
 * 线程不安全的懒加载
 * @version 1.0
 * @date 2021/1/2 21:34
 */
public class LazyLoadSingleton1 {
    @Test
    public void test(){
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
    }
}

class Singleton{
    //1.1私有化构造方法，防止直接外部new一个对象
    private Singleton(){}
    //1.2 静态常量直接创建一个对象
    private static Singleton instance = null ;

    //1.3提供一个加锁的公有的静态方法，当调用该方法的时候才创建对象
    public synchronized static Singleton getInstance(){
       if(instance == null){
           instance = new Singleton();
       }
        return instance;
    }
}

线程安全且支持懒加载，但是太重了，效率太低。每次获得单例都需要加锁

3、双重检查（推荐使用）

（1）双重校验（DCL double-chencked locking）

public class LazyLoadSingleton3 {
    @Test
    public void test(){
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
    }
}

class Singleton{
    //1.1私有化构造方法，防止直接外部new一个对象
    private Singleton(){}
    //1.2 静态常量直接创建一个对象
    private static volatile Singleton instance ;

    //1.3提供一个的公有的静态方法，当调用该方法的时候才创建对象
    public static Singleton getInstance(){
        if(instance == null){
            synchronized(Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

（2）面试中常见问题：为什么需要加volatile关键字？

当你执行instance = new SingletonC();这个操作的时候，实际上执行了三个步骤
	a).分配对象内存，
	b).调用构造方法，初始化数据
	c).将对象引用赋值给变量instance 
	由于JVM 执行的时候可以进行指令重排（java 内存模型）假设我们考虑这样的情形：当线程1
执行完步骤1，3，然后此时线程2进来判断instance不为空直接返回instance,很显然，此时的
instance 还没有初始化，这时候如果直接使用这个对象，这是有问题的

	而加了volatile 关键字的作用禁止指令重排序，就能避免上述情况的发生。
（如果上述解释听的有点迷糊的话，需要先进行volatile关键字的学习，学习是个循序渐进的过程，
不会不要紧，见得多了就会了）

（3）面试中常见问题：为什么需要两次判空，第二次判断为空的目的是什么？

*第一个if减少加锁开销，提升性能*；
	  	 假设如果没有这个判断，则每一次调用该方法获得对象的时候，都要进行加锁操作，很是消耗性能；
*第二个if避免并发情况下生成多个对象实例*
	     假设有2个线程A，B，假设线程A和线程B同时调用getInstance()时，第一个if判断都为空，假设这
	  时线程A先拿到锁，则线程B在代码块外层等待获取锁。线程A进行第二个if判断，发现条件成立new
	  了一个新对象，创建完成后释放锁；这个时候线程B拿到锁，进行第二个if判断，此时instance不空，
	  直接返回instance释放锁从而保证了并发安全，避免生成多个对象实例。

三、静态内部类实现单例

第一外部类加载的时候不会加载其静态内部类
第二由于类加载机制保证了静态内部类只会被加载一次，保证了线程安全（你是否还记得静态内部类的加载时机？）

public class StaticInnerClassSingleton {
    @Test
    public void test(){
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
    }
}
class Singleton{
    //1.1 私有化构造方法
    private Singleton(){}
    //1.2 编写静态内部类，静态内部类的特点
    public static class SingletonInstance{
        private static final Singleton instance  = new Singleton();
    }
    //1.3提供一个静态的获取单例的方法
    public static Singleton getInstance(){
        return SingletonInstance.instance;
    }
}

四、 枚举实现单例 （《Effective Java》上推荐的单例写法）

public class EnumSingleton {
    @Test
    public void test(){
        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance1 == instance2);
    }
}

/**
* 枚举
*/
 enum Singleton {
    INSTANCE;
    public void eat(){
        System.out.println("eat meat");
    }
}

五、各种创建单例的总结和对比

		优点	缺点
饿汉式	静态常量的饿汉式	简单，线程安全，随时随地使用起来的时候快	占用内存
	静态代码块饿汉式	简单，线程安全	占用内存
懒汉式	线程不安全懒汉式	简单，节约内存，实现了懒加载思想，第一次加载的时候慢一点	线程不安全，多线程情况下可能出现多个实例
	线程安全懒汉式	简单，粗暴，第一次加载的时候慢一点	线程安全且支持懒加载，但是太重了，效率太低。每次获得单例都需要加锁
	双重检查	第一次加载的时候慢一点	通过反射和反序列化进行更改
静态内部类	静态内部类创建单例	既能保证线程安全，又能实现懒加载	通过反射和反序列化进行更改
枚举	枚举创建单例	优雅,使用枚举除了线程安全和防止反射强行调用构造器之外，还提供了自动序列化机制，防止反序列化的时候创建新的对象	优雅，但是有点懒加载的味道