Java单例模式学习笔记（四种方式）

什么是单例模式？

单例模式是 Java 中最简单，也是最基础，最常用的设计模式之一。在运行期间，保证某个类只创建一个实例，保证一个类仅有一个实例，并提供一个访问它的全局访问点。下面就来讲讲Java中的N种实现单例模式的写法。

饿汉式

public class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }

}

这是实现一个安全的单例模式的最简单粗暴的写法，这种实现方式为饿汉式。之所以称之为饿汉式，是因为肚子很饿了，想马上吃到东西，不想等待生产时间。这种写法，在类被加载的时候就把Singleton实例给创建出来了。

饿汉式的缺点就是，可能在还不需要此实例的时候就已经把实例创建出来了，没起到lazy loading的效果。

饿汉式的优点就是实现简单，而且安全可靠，不存在线程安全问题。

懒汉式

public class Singleton {
    
    private static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
    
}

相比饿汉式，懒汉式显得没那么“饿”，在真正需要的时候再去创建实例。在getInstance方法中，先判断实例是否为空再决定是否去创建实例，看起来似乎很完美，但是存在线程安全问题。在并发获取实例的时候，可能会存在构建了多个实例的情况。所以，需要对此代码进行下改进。

public class SingletonSafe {
    // 问题1：解释为什么要加volatile？
    // synchronized代码块中指令还是会重排序的，执行构造方法的指令和赋值指令有可能会被重排序
    // 第二个线程再进syn代码块之前，获取对象引用时，可能会直接拿到的引用还没调用构造方法
    // 拿到的是一个不完整的引用（对象），因此加volatile防止syn代码块内指令重排序    
    private static volatile SingletonSafe singleton;

    private SingletonSafe() {
    }

    public static SingletonSafe getSingleton() {
// 问题2：为什么这里还要判断，之前不是判断过了吗？
// 为了防止首次创建SongletonSafe对象时多个线程并发的问题。
// 比如先后两个线程，线程1进入第一个if,之后执行同步代码块，在执行同步代码块过程中，线程2进入第一个if，如果通过代码块中不判断的话，t2最终也会创建一个新的对象
        if (singleton == null) {
            synchronized (SingletonSafe.class) {
                if (singleton == null) { 
                    singleton = new SingletonSafe();
                }
            }
        }
        return singleton;
    }
}

这里采用了双重校验(DCL)的方式，对懒汉式单例模式做了线程安全处理。通过加锁，可以保证同时只有一个线程走到第二个判空代码中去，这样保证了只创建 一个实例。这里还用到了volatile关键字来修饰singleton，其最关键的作用是防止指令重排。

Java volatile关键字最全总结：原理剖析与实例讲解(简单易懂)

静态内部类

public class Singleton {

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

    private Singleton() {
        
    }

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

通过静态内部类的方式实现单例模式是线程安全的，同时静态内部类不会在Singleton类加载时就加载，而是在调用getInstance()方法时才进行加载，达到了懒加载的效果。

似乎静态内部类看起来已经是最完美的方法了，其实不是，可能还存在反射攻击或者反序列化攻击。且看如下代码：

public static void main(String[] args) throws Exception {
    Singleton singleton = Singleton.getInstance();
    Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
    constructor.setAccessible(true);
    Singleton newSingleton = constructor.newInstance();
    System.out.println(singleton == newSingleton);
}

通过结果看，这两个实例不是同一个，这就违背了单例模式的原则了。

通过枚举实现单例模式（***）

 因为Java虚拟机会保证枚举对象的唯一性，因此每一个枚举类型和定义的枚举变量在JVM中都是唯一的。

最简单的实现方式如下代码所示：

public enum Singleton {
     INSTANCE;
     public void businessMethod() {
          System.out.println("我是一个单例！");
     }
}

大家可以看到，我们定义了一个枚举类型Singleton，在其中定义了一个枚举变量instance，同时还提供了业务方法businessMethod。

测试：

public class MainClass {
    public static void main(String[] args) {
        Singleton s1 = Singleton.INSTANCE;
        Singleton s2 = Singleton.INSTANCE;
        System.out.println(s1==s2); // true
    }
}

注： Java虚拟机会保证枚举类型不能被反射并且构造函数只被执行一次。当尝试使用反射破环时，会报错：IllegalArgumentException : Cannot reflectively create enum objects

---

问题一：枚举单例如何限制实例个数的？

enum Singleton {
    INSTANCE;
}

反编译的字节码为：

final enum com/hellodu/juc/test/Singleton extends java/lang.enum {
    public final static enum com/hellodu/juc/test/Singleton; INSTANCE;
}

INSTANCE就是枚举类中的一个静态成员变量，是单实例的

问题二：枚举单例在创建时有无并发问题？

没有，因为单例对象是静态成员变量，在类加载阶段完成初始化，由JVM保证线程安全性，多线程下不会出现安全问题

问题三：枚举单例能否用反射破坏？

不能，由JVM保证，反射在通过newInstance()创建对象时，会检查该类ENUM修饰，如果是则抛出异常，反射失败

问题四：枚举单例能否被反序列化机制破坏单例

不能，枚举类默认实现了序列化接口，可以被序列化和反序列化。因为枚举类父类中的反序列化是通过valueOf()实现的。

问题五：枚举单例属于饿汉式还是懒汉式？

因为静态成员变量在类加载是创建，所以属于饿汉式。

问题六：枚举单例如果希望加入一些单例创建的初始化逻辑该如何做？

加一个构造方法即可。