单例模式

单例的定义

确保某一个类只有一个实例，而且自行实例化并且向整个系统提供整个实例。

使用场景

确保一个类有且只有一个对象，避免产生多个对象消耗资源，比如访问IO和数据库等资源的时候就需要使用单例

实现方式

最简单的实现，线程不安全

保证只有一个对象，那么构造方法肯定得是私有的，通过一个静态方法获取对象，当对象为空的时候初始化对象，否则直接返回，需要用到的时候再去初始化，属于懒加载模式。

public class Singleton {
    private static Singleton singleton;
    private Singleton() {
    }
    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

缺点就是当多线程调用getInstance的时候可能会初始化多个对象，所以这个方法不可取

懒汉式，线程安全

那么可以加上有个同步来试试

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

其实这样是OK的，当执行方法的时候，在同一时刻只能有一个线程得到执行，另一个线程受阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块；但是有个小问题，这样效率比较低；所以可以稍微优化一下，把同步放到了判断为空以后

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

这个样子看起来是可以的，但是还是有一个小问题，不容易被发现；就是如果一个线程执行到singleton = new Singleton()这一步的时候（不属于原子操作），这句代码包括了三步，

给singleton分配内存，

调用 Singleton 的构造函数来初始化成员变量，

将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

在 JVM 的即时编译器中存在指令重排序的优化，上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2，所以如果直接执行了1-3-2，这时候刚好另一个线程执行进来，执行if (singleton == null)代码，判断不为空然后拿着对象去使用，但其实变量还没有初始化，程序就会出错；

双重检验锁模式

我们可以将singleton变量声明成volatile，它有一个特性就是禁止指令重排序优化，这样就没有问题了；

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

饿汉式 static final field

但是有没有发现上面这种方法写起来有点麻烦；所以简单点，可以直接使用静态变量

public class Singleton {
    private final static Singleton singleton = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return singleton;
    }
}

这种写法其实是OK的，可以使用的，缺点在于不是一种懒加载模式，加载类后就被初始化，即使可能用不到；而且在有些场景，比如需要传入参数时候，就不适用了

静态内部类 static nested class

我比较喜欢这种方法，感觉是比较好的，写起来也比较方便，这种方法也是《Effective Java》上所推荐的

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

枚举 Enum

枚举也是一种很好的方法，很简单，而且还能防止反序列化导致重新创建新的对象；但是好像一般也没什么人用，我觉得还OK

public enum  Singleton {
    SINGLETON;
    public static void main(String[] args){
        Singleton  singleton=Singleton.SINGLETON;
    }
}

使用容器实现单例模式

可以在程序初始化的时候将各种单例类型注入到一个统一的管理类中，根据key值来获取相应的对象，这也是一种方法

public class SingletonManager {
    private static Map<String, Object> objectMap = new HashMap<>();

    private SingletonManager() {
    }

    /**
     * 注入单例
     *
     * @param key
     * @param instance
     */
    public static void registerService(String key, Object instance) {
        if (!objectMap.containsKey(key)) {
            objectMap.put(key, instance);
        }
    }

    /**
     * 获取单例
     *
     * @param key
     * @return
     */
    public static Object getService(String key) {
        return objectMap.get(key);
    }

}

总结

大概也就这几种常见的单例写法，其实就是为了确保一个类有且只有一个对象，自己觉得哪种合适，哪种方便就使用哪种好了；