常见的单例模式及其实现方式

---

前言

单例模式有多种不同的实现方式，并且各个实现也有其自己的特点或不足

---

一、什么是单例模式？

单例模式定义：确保某一个类只有一个实例，并且自行实例化后向整个系统提供这个实例。
（独苗，该类只有一个实例对象，其他类要使用这个类时只能去"借"不能去new）

二、单例模式的实现

1.单例模式

创建一个单例类需要实现的三步

1. 私有的静态变量作为单例对象
2. 私有化构造方法
3. 提供公共的静态获取方法

//1. 饿汉式（静态变量）
class Singleton01{
    //1.单例变量
    private  static Singleton01 instance = new Singleton01();
    //2.私有化构造方法，防止通过new创建对象
    private Singleton01(){};
    //3.提供公共的获取方法
    public static Singleton01 getInstance(){
        return instance;
    }
}

由于是单例，不允许有多个实例，因此需要将构造方法私有化来防止通过new创建对象实例。静态变量会随着类的加载而加载，所以在Singleton01类被加载时就会创建instance单例实例对象，并且只会被加载创建一次。最后向外暴露一个公共的获取方法使得每次调用方法时返回该同一个单例对象。

我们也可以将单例对象的创建放在静态代码块中，因为静态代码块的执行时机也是在类加载的时候，并且有且只执行一次：

//1. 饿汉式（静态代码块）
class Singleton02{
    //1.单例变量
    private  static Singleton02 instance;
    static{
		instance = new Singleton02();
	}
    //2.私有化构造方法，防止通过new创建对象
    private Singleton02(){};
    //3.提供公共的获取方法
    public static Singleton02 getInstance(){
        return instance;
    }
}

因为每次当Singleton01单例类被加载时，instance实例就会被创建，因此这种模式也称为饿汉式单例模式，如果从始至终都没有使用过这个单例实例，则会造成内存浪费。

2.单例模式（懒加载）

若把单例实例创建时机推迟到获取方法第一次调用才创建，这种通过懒加载的方式实现的单例模式就是懒汉式单例模式。

class Singleton03{
    //1.单例变量
    private static Singleton03 instance;
    //2.私有化构造方法
    private Singleton03(){};
    //3.提供公共的获取方法 (在获取时创建)
    public static Singleton03 getInstance(){
        if (instance == null){
            instance = new Singleton03();
        }
        return instance;
    }
}

这种单例模式在单线程下是可行的，但是在多线程下则是线程不安全的，假设某一时刻有A，B，C三个线程同时去执行获取方法getInstance()，在执行到if判断时，由于单例实例还没创建，因此都去执行if中的语句，这时多个线程就创建了多个实例对象。为了使得该模式线程安全，可行的改进是在获取方法上加 synchronized 同步锁。

//懒汉式(线程安全)
class Singleton04{
    //1.单例变量
    private static Singleton04 instance;
    //2.私有化构造方法
    private Singleton04(){};
    //3.提供公共的获取方法 (在获取时创建)
    public static synchronized Singleton04 getInstance(){
        if (instance == null){
            instance = new Singleton04();
        }
        return instance;
    }
}

通过加锁的方式，使得该单例模式线程安全，但也因为加锁的原因导致性能下降严重，假设多个线程都要获得该单例实例，则都需要先去竞争获取同步锁，性能较低。

3.单例模式（双重检查）

我们需要的是确保单例实例只被创建一次，同时还希望有不错访问效率，因此可使用双重检查的方式来实现单例模式

class Singleton05{
    //1.单例变量
    private static volatile Singleton05 instance;
    //2.私有化构造方法
    private Singleton05(){};
    //3.提供公共的获取方法 (懒汉式体现在获取方法被调用时才创建)
    public static Singleton05 getInstance(){
        if (instance == null){
            synchronized (Singleton05.class){
                if (instance == null){
                    instance = new Singleton05();
                }
            }
        }
        return instance;
    }
}

获取方法本身不在是同步方法，提高了访问效率，当单例实例 instance 已经被创建时，线程在调用该方法就会直接返回单例对象。当单例实例还没创建时，假设A,B,C三个线程都执行到了第一个if检查，则当前时刻3个线程if表达式为真，则进入同步锁竞争，拿到锁的线程才能执行同步块内的内容，若A先拿到锁，则率先执行第二个if检查，判断为 true，则执行单例实例的创建，B线程和C线程在A线程执行完后再去获得锁执行第二个检查，此时第二个if判断 由于instance已经被A线程创建了，所以为false，不执行对象创建语句，这就保证了单例实例在多线程下只创建一次。
另外，为了保证单例实例创建后，保证对其他线程的可见性，单例实例需要被volatile来修饰。

4.单例模式（静态内部类）

我们也可以通过静态内部类来实现单例模式，将单例变量放在一个静态内部类中，在获取方法中调用该静态内部类的属性

//静态内部类实现单例
class Singleton06{
    //1.单例变量 (将单例变量封装进静态内部类中)
    private static class SingletonInstance{
        private static Singleton06 instance = new Singleton06();
    }
    //2.私有化构造方法
    private Singleton06(){};
    //3.提供公共的获取方法 (返回内部静态类的 Instance 属性，从而触发静态内部类加载，在加载的时候创建单例对象)
    public static Singleton06 getInstance(){
        return SingletonInstance.instance;
    }
}

当Singleton06类被加载的时候，该类的SingletonInstance静态内部类不会被加载，而是在第一次调用获取方法时，才会触发SingletonInstance静态内部类的装载，在它装载时才去创建初始化静态变量instance （单例实例），而这一过程JVM保证它是线程安全的。这就确保了懒加载的同时单例实例对象只被创建一次。

总结

单例模式还可以通过枚举来实现，在使用这些单例模式时，可根据需求灵活选择，单例模式（双重检查）、单例模式（静态内部类）和（枚举）由于可保证线程安全因此在多线程环境下推荐使用。