Java 单例模式的几种写法

所谓单例，就是确保一个类只有一个实例，并提供该实例的全局访问点。

使用一个私有构造函数、一个私有静态变量以及一个公有静态函数（返回该静态变量）来实现。

私有构造函数保证了不能通过构造函数来创建对象实例，只能通过公有静态函数返回唯一的私有静态变量。

1. 懒汉式 (线程不安全, 不可用)

public class Singleton_exam {

    private static Singleton_exam uniqueInstance;

    private Singleton_exam() {
    }

    // 懒汉式，私有静态变量被延迟实例化，节约资源
    // 多线程环境下不安全 (多个线程同时进入getInstance()方法, 且对象实例为null)
    public static Singleton_exam getInstance() {
        if(uniqueInstance == null ) {
            uniqueInstance = new Singleton_exam();
        }
        return uniqueInstance;
    }
}

如果没有用到该类，就不会实例化 uniqueInstance, 从而节约资源。

在多线程环境下线程不安全，多个线程同时进入 if 语句，并且此时 uniqueInstance 为 null, 那么将导致实例化多次 uniqueInstance。

2. 饿汉式(静态常量, 可用), 线程安全

public class Singleton_exam2 {

    // 饿汉式，线程安全
    // 缺点：丢失了延迟实例化带来的节约资源的好处
    private static Singleton_exam2 uniqueInstance = new Singleton_exam2();

    private Singleton_exam2() { }

    public static Singleton_exam2 getInstance() {
        return uniqueInstance;
    }
}

写法比较简单，在类装载的时候完成实例化，避免了线程同步问题。

3.  懒汉式 (线程安全, 同步方法, 不推荐)

public class Singleton_exam3 {

    private static Singleton_exam3 uniqueSingle;

    private Singleton_exam3() {

    }

    public static synchronized Singleton_exam3 getInstance() {
        if(uniqueSingle == null) {
            uniqueSingle = new Singleton_exam3();
        }
        return uniqueSingle;
    }
}

对 getInstance() 方法进行了线程同步。

缺点：性能问题，效率太低。每个线程在获得类实例的时候，执行该方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低要改进。

4. 双重校验(推荐)

public class Singleton_exam4 {

    private volatile static Singleton_exam4 uniqueSingle;

    private Singleton_exam4() {}

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

Double-Check概念。

对私有变量 uniqueSingle 采用 volatile 关键字修饰，是必要的。因为 uniqueSingle = new Singleton_exam4() 实际上是分为三步执行。

1. 为 uniqueSingle 分配内存空间
2. 初始化 uniqueSingle
3. 将 uniqueSingle 指向分配的内存地址。

在没有加 volatile 关键字时，要考虑到 JVM 的指令重排，所以，上述的执行顺序可能会变成 1 -> 3 -> 2。 因此，在多线程环境下，考虑线程 T1 执行了 1, 3, 而 此时线程 T2 调用 getInstance() 后发现 uniqueSingle 不为空，因此返回了未被初始化的 uniqueSingle。 (我们知道，volatile关键字的几个作用，1. 可见性  2. 禁止指令重排(内存屏障) )

进行了两次 if ( uniqueSingle == null ) 检查，是必要的。考虑下面的这种情况，只是用了一个 if 语句。 在 uniqueSingle == null 的情况下，如果两个线程都执行了 if 语句，那么两个线程都将进入 if 语句块内。即就是两个线程都将执行 uniqueSingle = new Singleton_exam4() ； 那么就会进行两次实例化。因此，必须避开这种情况 ，使用两个 if 语句。

if (uniqueSingle == null) {
    // 两个线程同时进入此处，执行下面的代码
    synchronized (Singleton.class) {
        uniqueSingle = new Singleton();
    }
}

5. 静态内部类实现(推荐)

public class Singleton_exam5 {
    
    private Singleton_exam5() {}
    
    private static class SingletonHolder {
        private static final Singleton_exam5 INSTANCE = new Singleton_exam5();
    }
    
    public static Singleton_exam5 getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

当 Singleton_exam5 类加载时，静态内部类 SingletonHolder 还没有被加载进内存。只有当调用 getInstance() 方法触发 SingletonHolder.INSTANCE 时 SingletonHolder 才会被加载，此时才初始化 INSTANCE实例， 并且 JVM 确保 INSTANCE 只被实例化一次。

这种方法不仅具有延迟初始化的好处，而且由JVM提供了对线程安全的支持。

6. 枚举实现(推荐)

优点

系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

缺点

当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new，可能会给其他开发人员造成困扰，特别是看不到源码的时候。

 

参考链接：https://www.cnblogs.com/zhaoyan001/p/6365064.html

https://cyc2018.github.io/CS-Notes/#/notes/