单例模式解析

单例模式的设计要点

1. 保证只有一个实例
   私有构造方法，确保其他处的代码无法通过调用该类的构造方法来实例化
2. 保证只有一个该实例的访问点
   静态方法作为该实例的访问点

懒汉和饿汉的概念

饿汉：申明实例引用的时即实例化
懒汉：在第一次被调用之前不实例化，即懒加载。对于创建实例代价大，且不确会是否会被使用的，可以使用懒加载模式减少开销

单例模式的实现方式

1.【线程不安全】【懒汉模式】

public class Singleton1 {
    private static Singleton1 INSTANCE;
    private Singleton1(){}
    public static Singleton1 getInstance(){
        if (INSTANCE == null) {
            INSTANCE = new Singleton1();
        }
        return INSTANCE;
    }
}

2. 【线程安全】【懒汉模式】

public class Singleton2 {
    private static Singleton2 INSTANCE;
    private Singleton2(){}
    public static synchronized Singleton2 getInstance(){
        if (INSTANCE == null) {
            INSTANCE = new Singleton2();
        }
        return INSTANCE;
    }
}

3. 【本质上线程不安全】【懒汉模式】

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

4. 【双重校验】【懒汉模式】【线程安全】

public class Singleton4 {
    private static volatile Singleton4 INSTANCE;
    private Singleton4(){}
    public static Singleton4 getInstance(){
        if (INSTANCE == null) {
            synchronized (Singleton4.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton4();
                }
            }
        }
        return INSTANCE;
    }
}

5. 【静态代码块】【饿汉模式】【线程安全】

public class Singleton5 {
    private stati Singleton5 INSTANCE;
    private Singleton5(){}
    static {
        INSTANCE = new Singleton5();
    }
    public static Singleton5 getInstance(){
        return INSTANCE;
    }
}

6. 【内部类】【饿汉模式】【线程安全】

public class Singleton6 {
    private static Singleton6 INSTANCE;

    private Singleton6() { }

    private static class InnerClass {
        private static final Singleton6 singleton6 = new Singleton6();
    }

    public static Singleton6 getInstance() {
        return InnerClass.singleton6;
    }
}

7. 【静态成员】【饿汉模式】【线程安全】

public class Singleton7 {
    private static final Singleton7 INSTANCE = new Singleton7();

    private Singleton7() {}

    public static Singleton7 getInstance() {
        return INSTANCE;
    }
}

8. 【枚举】【饿汉模式】【线程安全】

public enum Singleton8 {
    INSTANCE;

    private Singleton8() {}

    public void doSomeThing() {}
}

方法序号	优点	缺点
1	实现了懒汉的功能	线程不安全，多线程环境下可能有多个实例
2	实现了懒汉的功能，线程安全	正常情况下使用能保证线程安全，每次都需要获取锁，资源消耗大，效率低
3	不需要每次调用都获取锁，提高了效率	本质上是线程不安全的，具体原因见图1
4	使用了双重检查，避免了线程不安全，同时也避免了不必要的锁开销
5	线程安全
6	实现简单，无线程同步问题
7	线程安全
8	枚举，线程安全

图1 第三种实现方法不安全的原因
双重校验的单例实现方式申明的时候用volatile修饰，这是因为一个成员变量从申明到实例化的过程不是原子操作，其具体可分为：

• 分配内存空间
• 初始化对象
• 将内存空间的地址赋值给对应的引用

但是由于操作系统可以对指令进行重排序，所以上面的过程也可能会变成如下过程：

• 分配内存空间
• 将内存空间的地址赋值给对应的引用
• 初始化对象

如果是这个流程，多线程环境下就可能将一个未初始化的对象引用暴露出来，从而导致不可预料的结果。因此，为了防止这个过程的重排序，我们需要将变量设置为volatile类型的变量。

参考文献

你真的用对单例模式了吗？
单例模式：双重锁校验可能存在的问题