Java单例进化史

关于单例，从我学Java到现在只知道以下两点：

1.为了让一个类只能有一个实例，所以使用单例的设计模式。

2.有两种实现方法：①饿汉式 ②懒汉式

①饿汉式简单，是线程安全的。但是在类加载时就创建了一个实例，但是这个单例类可能永远不会被使用，这就造成了浪费。而且类被加载器加载时就会实例化一次。这就有可能被实例化多次。

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {
    }

    public static Singleton getSingleton() {
        return INSTANCE;
    }
}

②懒汉式 只有在调用getInstance方法的时候才开始实例化。 但是不是线程安全的，所以要在方法上加synchronized关键字，但是加了同步后每次只能被一个线程调用，性能大大降低。所以出来一种DCL机制。 所谓DCL就是 Double Checked Locking。 

public class DoubleCheckedLockingSingleton {
    private volatile DoubleCheckedLockingSingleton INSTANCE;

    private DoubleCheckedLockingSingleton() {
    }

    public DoubleCheckedLockingSingleton getInstance() {
        if (INSTANCE == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                // double checking Singleton instance
                if (INSTANCE == null) {
                    INSTANCE = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return INSTANCE;
    }

    // readResolve to prevent another instance of Singleton
    private Object readResolve() {
        return INSTANCE;
    }
}

这种方法还有问题。因为new DoubleCheckedLockingSingleton(); 不是原子的。

1. 给 instance 分配内存
2. 调用 Singleton 的构造函数来初始化成员变量
3. 将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

所以要使用volatile关键字。用来防止代码被优化时乱序。即使这样在Jdk1.5之前还是有问题，因为其他地方的代码不是volatile的。这个问题在jdk.1.5版本中修复了。

加上volatile之后还是有问题。因为反序列化时还是会创建多个实例。所以又要在单例类里加上这句防止反序列化时破坏

// readResolve to prevent another instance of Singleton
private Object readResolve() {
    return INSTANCE;
}

jdk1.5出了一个枚举类型。用枚举实现单例可谓一举数得。代码简单，完美实现单例

public enum EasySingleton {
    INSTANCE;
}

注意枚举里 调用 EasySingleton.INSTANCE返回来的类型就是EasySingleton它自己。

enum fields are compile time constants, but they are instances of their enum type. And, they're constructed when the enum type is referenced for the first time.

以下是我参考的文章：

为什么java中用枚举实现单例模式会更好

设计模式（二）——单例模式

Java实现单例的难点

Java高新技术2--JAVA中枚举的各种应用以及单例模式