持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第3天，点击查看活动详情

单例模式（Singleton Pattern），就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。

比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对像。SessionFactory 并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory 就够，这时就会使用到单例模式。

单例模式有九种实现方式（黑体字为可用的）：

静态常量（饿汉式）
静态代码块（饿汉式）
普通方法（懒汉式）- 线程不安全
同步方法（懒汉式）- 效率太低
同步代码块（懒汉式）- 线程不安全
双重检查锁（懒汉式）
静态内部类（懒汉式）
枚举
CAS

1. 静态常量（饿汉式）

public class Singleton01 {
    /**
     * 构造方法私有化，防止在外部被实例化
     */
    private Singleton01(){}

    /**
     * 静态实例私有化，防止在外部被引用
     */
    private static final Singleton01 INSTANCE = new Singleton01();

    /**
     * 提供公开的静态方法，用来在外部获取实例
     */
    public static Singleton01 getInstance(){
        return INSTANCE;
    }
}

优缺点说明：

优点：这种写法比较简单，就是在类装载的时候就完成实例化，避免了线程同步问题。
缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。
这种方式基于 Classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数情况都是调用 getInstance 方法触发类装载的，但是导致类装载的原因有很多种，因此不能确定是否会有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 就没有达到 Lazy Loading 的效果。
结论：这种单例模式可用，但可能会造成内存浪费。

2. 静态代码块（饿汉式）

public class Singleton02 {
    /**
     * 构造方法私有化，防止在外部被实例化
     */
    private Singleton02(){}

    /**
     * 静态实例私有化，防止在外部被引用
     */
    private static final Singleton02 INSTANCE;

    static {
        //在静态代码块中进行初始化
        INSTANCE = new Singleton02();
    }

    /**
     * 提供公开的静态方法，用来在外部获取实例
     */
    public static Singleton02 getInstance(){
        return INSTANCE;
    }
}

优缺点说明：

这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
结论：这种单例模式可用，但可能会造成内存浪费。

3. 普通方法（懒汉式）

public class Singleton03 {
    /**
     * 构造方法私有化，防止在外部被实例化
     */
    private Singleton03(){}

    /**
     * 静态实例私有化，防止在外部被引用
     */
    private static Singleton03 instance;

    /**
     * 提供公开的静态方法，用来在外部获取实例
     */
    public static Singleton03 getInstance(){
        if (instance == null){
            instance = new Singleton03();
        }
        return instance;
    }
}

优缺点说明：

起到了 Lazy Loading 的效果，但是只能在单线程下使用。
如果在多线程下，一个线程进入了if (instance == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。
结论：在实际开发中，不要使用这种方式。

4. 同步方法（懒汉式）

public class Singleton04 {
    /**
     * 构造方法私有化，防止在外部被实例化
     */
    private Singleton04(){}

    /**
     * 静态实例私有化，防止在外部被引用
     */
    private static Singleton04 instance;

    /**
     * 提供公开的静态方法，用来在外部获取实例
     */
    public static synchronized Singleton04 getInstance(){
        if (instance == null){
            instance = new Singleton04();
        }
        return instance;
    }
}

优缺点说明：

解决了线程不安全问题。
效率太低了，当每个线程在想获得类的实例时候，执行 getInstance() 方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低。
结论：在实际开发中，不推荐使用这种方式。

5. 同步代码块（懒汉式）

public class Singleton05 {
    /**
     * 构造方法私有化，防止在外部被实例化
     */
    private Singleton05() {
    }

    /**
     * 静态实例私有化，防止在外部被引用
     */
    private static Singleton05 instance;

    /**
     * 提供公开的静态方法，用来在外部获取实例
     */
    public static Singleton05 getInstance() {
        if (instance == null) {
            synchronized (Singleton05.class) {
                instance = new Singleton05();
            }
        }
        return instance;
    }
}

优缺点说明：

这种方式，本意是想对第 4 种实现方式进行改进，因为前面同步方法效率太低，改为同步产生实例化的代码块。
但是这种同步并不能起到线程同步的作用。跟第 3 种实现方式遇到的情形一致，假如一个线程进入了if (instance == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。
结论：在实际开发中，不能使用这种方式。

6. 双重检查锁（懒汉式）

DCL(Double Check Lock)，双重检查锁。注意 volatile 关键字的使用。

public class Singleton06 {
    /**
     * 构造方法私有化，防止在外部被实例化
     */
    private Singleton06() {
    }

    /**
     * 静态实例私有化，防止在外部被引用
     */
    private static volatile Singleton06 instance;

    /**
     * 提供公开的静态方法，用来在外部获取实例
     */
    public static Singleton06 getInstance() {
        if (instance == null) {
            synchronized (Singleton06.class) {
                if (instance == null) {
                    instance = new Singleton06();
                }
            }
        }
        return instance;
    }
}

优缺点说明：

Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if (instance == null)检查，这样就可以保证线程安全了。
实例化代码只用执行一次，后面再次访问时，判断if (instance == null)，直接 return 实例化对象，也避免了反复进行方法同步。
线程安全；延迟加载；效率较高。
结论：在实际开发中，推荐使用这种单例设计模式。

volatile 关键字保证线程修改的可见性

Java 语言编写的程序，有时为了提高运行效率，编译器会自动对其优化，把经常访问的变量缓存起来，程序在读取这个变量时有可能直接从缓存（例如寄存器）中读取，而不会去内存中读取。当多线程编程时，变量的值可能因为被别的线程改变了，而该缓存的值没有相应的改变，从而造成该变量读取的值与实际的值不一致。

volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

volatile 关键字禁止指令重排序

在 Java 内存模型(JMM)中，并不限制处理器的指令顺序，说白了就是在不影响结果的情况下，顺序可能会被打乱。

在执行instance = new Singleton06();这条语句时，JMM 并不是一下就执行完毕的，即不是原子性的，实质上这句命令分为三大部分：

为对象分配内存空间，字段赋默认值。（申请空间）
执行构造方法语句，初始化实例对象。（初始化对象）
把instance引用指向分配的内存空间。（引用关联）

在 JMM 中这三个步骤中的2和3不一定是顺序执行的，如果线程A执行的顺序为1、3、2，在第2步执行完毕的时候，恰好线程B执行第一次判空语句，则会直接返回instance，那么此时获取到的instance仅仅只是不为null，实质上并没有初始化完毕，这样的对象肯定是有问题的！（也就是说线程B可能获取到半初始化状态的对象，该对象内部的各字段的值都还是各类型的默认值，并未完成值的初始化。）

而volatile关键字的存在意义就是保证了执行命令不会被重排序，也就避免了这种异常情况的发生，所以这种获取单例的方法才是真正的安全可靠！

volatile 关键字的缺点：使用 volatile 屏蔽掉了 JVM 中必要的代码优化，所以在执行效率上会比较低。

7. 静态内部类（懒汉式）

静态内部类不会因为外部类加载而加载，只会在用到的时候加载。

public class Singleton07 {
    /**
     * 构造方法私有化，防止在外部被实例化
     */
    private Singleton07() {
    }

    /**
     * 使用静态内部类维护单例
     */
    private static class InstanceFactory{
        private static final Singleton07 INSTANCE = new Singleton07();
    }

    /**
     * 提供公开的静态方法，用来在外部获取实例
     */
    public static Singleton07 getInstance() {
        return InstanceFactory.INSTANCE;
    }
}

优缺点说明：

这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
静态内部类方式在 Singleton07 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 InstanceFactory 类，从而完成 Singleton07 类的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
优点：避免了线程不安全，利用静态内部类的特点实现延迟加载，效率高。
结论：推荐使用。

8. 枚举

public enum Singleton08 {
    INSTANCE;
}

使用的时候直接通过Singleton08 instance = Singleton08.INSTANCE;获取实例。

优缺点说明：

这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式。
结论：推荐使用。

9. CAS

以上几种实现，其实现原理都是利用了类加载的时候初始化单例，即借助了 ClassLoader 的线程安全机制。所谓 ClassLoader 的线程安全机制，就是 ClassLoader 的 loadClass 方法在加载类的时候使用了synchronized关键字。也正是因为这样，除非被重写，这个方法默认在整个装载过程中都是同步的，也就是保证了线程安全。

所以，以上几种方法，虽然有的实现并没有显式的使用synchronized，但是其底层实现原理还是用到了synchronized。

不使用锁的话，有办法实现线程安全的单例吗？有的，那就是使用CAS。CAS是项乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都会失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。

CAS(Compare And Swap)比较和替换是设计并发算法时用到的一种技术。

public class Singleton09 {
    /**
     * 构造方法私有化，防止在外部被实例化
     */
    private Singleton09() {
    }

    /**
     * 静态实例私有化，防止在外部被引用（使用原子类包装）
     */
    private static final AtomicReference<Singleton09> INSTANCE = new AtomicReference<>();

    /**
     * 提供公开的静态方法，用来在外部获取实例
     */
    public static Singleton09 getInstance() {
        //死循环，相当于 while(true){}
        for (; ; ) {
            Singleton09 instance = INSTANCE.get();
            if (instance != null) {
                return instance;
            }
            instance = new Singleton09();
            //CAS 操作，如果 INSTANCE 为 null，则把它修改为 instance
            if (INSTANCE.compareAndSet(null, instance)) {
                return instance;
            }
        }
    }
}

优缺点说明：

用CAS的好处在于不需要使用传统的锁机制来保证线程安全，CAS是一种基于忙等待的算法，依赖底层硬件的实现，相对于锁它没有线程切换和阻塞的额外消耗，可以支持较大的并行度。
CAS的一个重要缺点在于如果忙等待一直执行不成功（一直在死循环中），会对 CPU 造成较大的执行开销。另外，如果 N 个线程同时执行到instance = new Singleton09();的时候，会有大量对象创建，很可能导致内存溢出。

10. 注意事项

在 JDK 源码中，java.lang.RunTime类就是经典的单例模式（饿汉式）。

public class Runtime {
    private static final Runtime currentRuntime = new Runtime();

    public static Runtime getRuntime() {
        return currentRuntime;
    }

    private Runtime() {}
    
    ...
}

单例模式注意事项和细节说明

单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new。
单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多（即：重量级对象），但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如数据源、session 工厂等）。

创建型设计模式之单例模式

1. 静态常量（饿汉式）

2. 静态代码块（饿汉式）

3. 普通方法（懒汉式）

4. 同步方法（懒汉式）

5. 同步代码块（懒汉式）

6. 双重检查锁（懒汉式）

7. 静态内部类（懒汉式）

8. 枚举

9. CAS

10. 注意事项