你真的了解单栗吗

我所知道的单利有三种：
以下是单例模式的特点：
1. 单例类只能有一个实例。
2. 单例类必须自己自己创建自己的唯一实例。
3. 单例类必须给所有其他对象提供这一实例。

1.饿汉式
饿汉式是典型的空间换时间，当类装载的时候就会创建类的实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断，节省了运行时间，使用起来绿色环保，因为简单易懂，当实现了serializable接口后，反序列化时单例会被破坏，实现了serializable接口需要重写readResolve，
才能保证其反序列化的时候依旧是单例
//饿汉式单例类.在类初始化时，已经自行实例化
public class Singleton {
private Singleton() {
}
private static final Singleton single = new Singleton();
//静态工厂方法
public static Singleton getInstance() {
return single;
}
}
private Object readResolve() throws ObjectStreamException {
return single;
}
2.懒汉式
懒汉么，所以在多线程下会失效，所以下面介绍三种懒汉的升级版来适应多线程
2.1在getinstance前加上synchronized（同步），但这导致的是每次getInstance都会去同步，消耗资源。
public class Singleton {
private Singleton() {
}
private static Singleton single = null;
// 静态工厂方法
public static synchronized Singleton getInstance() {
if (single == null) {
single = new Singleton();
}
return single;
}
}
2.2双重检查锁，它是在以上做的修改，判断两次空，所以只有在第一次调用的时候会同步，避免了每次同步资源的消耗，注意 volatile 关键字。
public class Singleton {
private Singleton() {
}
private volatile static Singleton singleton = null; // 声明成 volatile
//静态工厂方法
public static Singleton getInstance() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
2.3内部静态类，这种我觉得是最好的，既实现了线程安全，也避免了同步带来的性能影响。
public class Singleton {
private static class LazyHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton() {
}
public static Singleton getInstance() {
return LazyHolder.INSTANCE;
}
}
3.枚举
public enum SomeThing {
INSTANCE;
private Resource instance;
SomeThing() {
instance = new Resource();
}
public Resource getInstance() {
return instance;
}
}
以上就是常用的单例模式，一般的情况下，我会使用饿汉式，只有在要明确实现lazy loading（不是翻译成懒,差不多算延迟、推迟的意思。 是说不在初始化时loading,而是推迟到必须loading时才进行loading。）效果时才会使用内部静态类，另外，如果涉及到反序列化创建对象时我会试着使用枚举的方式来实现单例，不过，我一直会保证我的程序是线程安全的。