单例模式也就是说，一个应用程序启动后，整个应用中只有一个实例。单例模式有许多种写法。应用于不同的场景。

单例模式通常的实现方式在于构造函数私有化，然后暴露一个静态方法用于获取唯一实例。

public class HungrySingleton {
    private static final HungrySingleton instance = new HungrySingleton();
    private HungrySingleton(){}
    public static HungrySingleton getInstance() {
        return instance;
    }
}

饿汉式在程序加载时即初始化实例，不能懒加载。

public class LazySingleton {
    private static LazySingleton instance;
    private LazySingleton(){}
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

上述懒汉式实现的缺点是多线程下可能产生多个实例。

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

双重锁检验解决了多线程问题。但实现略繁琐。EffectiveJava推荐了下面的内部静态类的实现方式。

在内部声明一个私有的静态类，用于构建单例对象。该对象是懒加载的（因为JVM的类加载机制）。

public class InnerClassSingleton {
    private static class Builder {
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }

    private InnerClassSingleton() {}

    public static InnerClassSingleton getInstance() {
        return Builder.instance;
    }
}

如果不考虑反射，内部静态类应该就是最好的实现了。下面这种写法可以解决反射问题。

枚举不能实现懒加载，但可解决多线程、反射问题。且性能高，实现简单。

public enum EnumSingleton {
    INSTANCE;
}