最简单易懂的设计模式——单例模式

定义

Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”

写法

1.饿汉式

public class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }

}

这种方式在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。这种方式避免了多线程的同步问题。在类加载的时候就完成实例化，没有达到懒加载的效果。如果从始至终未使用过这个实例，则会造成内存的浪费。

2.懒汉式（线程不安全）

public class Singleton {

    private static Singleton instance;

    private Singleton() {
        
    }

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

}

懒汉模式声明了一个静态对象，在第一次调用时初始化。这虽然节约了资源，但第一次加载时需要实例化，反应稍慢一些，而且在多线程时不能正常工作。

3.懒汉式（线程安全）

public class Singleton {

    private static Singleton instance;

    private Singleton() {

    }

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

}

种写法能够在多线程中很好地工作，但是每次调用getInstance方法时都需要进行同步。这会造成不必要的开销，而且大部分时候我们是用不到同步的。所以，不太建议用这种模式。

4.双重检查模式（DCL）

public class Singleton {

    private volatile static Singleton instance;

    private Singleton() {

    }

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

}

这种写法在getInstance方法中对Singleton进行了两次判空：第一次是为了不必要的同步，第二次是在instance等于null的情况下才创建实例。

DCL的优点是资源利用率高。第一次执行getInstance时单例对象才被实例化，效率高。其缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷。DCL虽然在一定程度上解决了资源的消耗和多余的同步、线程安全等问题，但其还是在某些情况会出现失效的问题，也就是DCL失效。这里建议用静态内部类单例模式来替代DCL。

这里为什么要使用volatile呢？
上面这种写法看似很完美，但实际上仍然存在一个问题——当instance不为null时，可能指向一个"被部分初始化的对象"。问题出在这行简单的赋值语句：

instance = new Singleton();

它并不是一个原子操作。可以”抽象“为下面几条JVM指令：

memory = allocate();    //1：分配对象的内存空间
ctorInstance(memory);   //2：初始化对象
instance = memory;      //3：设置instance指向刚分配的内存地址

上面2依赖于1，但是3并不依赖于2，所以JVM可以以“优化”为目的对它们进行重排序，经过重排序后如下：

memory = allocate();    //1：分配对象的内存空间
instance = memory;      //3：设置instance指向刚分配的内存地址（此时对象还未初始化）
ctorInstance(memory);   //2：初始化对象

可以看到指令重排序之后， 3 排在了 2 之前，即引用instance指向内存memory时，这段崭新的内存还没有初始化——即，引用instance指向了一个"被部分初始化的对象"。此时，如果另一个线程调用getInstance方法，由于instance已经指向了一块内存空间，从而if条件判为false，方法返回instance引用，用户得到了没有完成初始化的“半个”单例。

解决该问题，只需要将instance声明为volatile变量。在这里使用volatile会或多或少地影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。

5.静态内部类单例

public class Singleton {

    private Singleton() {

    }

    public static Singleton getInstance() {
        return SingletonLazyHolder.sInstance;
    }

    private static class SingletonLazyHolder {
        private static final Singleton sInstance = new Singleton();
    }

}

第一次加载Singleton类时并不会初始化sInstance，只有第一次调用getInstance方法时虚拟机加载SingletonLazyHolder 并初始化 sInstance。这样不仅能确保线程安全，也能保证Singleton 类的唯一性。所以，推荐使用静态内部类单例模式。

6.枚举单例

public enum Singleton {

    INSTANCE
    /*其他方法*/
}

上面就是枚举单例模式，需要小心的是如果你在使用实例方法，那么你需要确保线程安全。默认枚举实例的创建是线程安全的，但是在枚举中的其他任何方法由开发人员自己处理。枚举单例的优点就是简单，但是大部分应用开发很少用枚举，其可读性并不是很高。

使用场景

单例模式可能的使用场景如下：
1.整个项目需要一个共享访问点或共享数据。
2.创建一个对象需要耗费的资源过多，比如访问I/O或者数据库等资源。
3.工具类对象等。