单例模式

设计模式

单例的定义

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

使用场景

确保一个类有且只有一个对象，避免产生多个对象消耗资源，比如访问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) {
                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) {
                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;
    }
}

总结

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