单例模式

单例模式是最常见的模式，下面是五种不同的创建方式，常用的是双重检索和内部类方式。

• 懒汉式（线程安全，调用效率不高。但是，可以延时加载）
• 饿汉式（线程安全，调用效率高。但是，不能延时加载）
• 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
• 静态内部类（线程安全，调用效率高。但是，可以延迟加载）
• 枚举（线程安全，调用效率高，不能延迟加载）

双重检测锁式方式如果不带volatile会有线程安全隐患，这个隐患来自于代码中注释了 volatile 的一行，这行代码大致有以下三个步骤：

1 在堆中开辟对象所需空间，分配地址
2 根据类加载的初始化顺序进行初始化
3 将内存地址返回给栈中的引用变量

由于 Java 内存模型允许“无序写入”，有些编译器因为性能原因，可能会把上述步骤中的 2 和 3 进行重排序，顺序就成了

1 在堆中开辟对象所需空间，分配地址
2 将内存地址返回给栈中的引用变量（此时变量已不在为null，但是变量却并没有初始化完成）
3 根据类加载的初始化顺序进行初始化
现在考虑重排序后，两个线程出现了如下调用：

此时 T7 时刻 Thread B 对 instance 的访问，访问到的是一个还未完成初始化的对象。所以在使用 instance 时可能会出错。
而使用了volatile关键字后，重排序被禁止，所有的写（write）操作都将发生在读（read）操作之前，在 JDK5 及之后有效。

public class Singleton {
    private Singleton() {
    }


    // 懒汉式
    private static Singleton instance;

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
    //饿汉式
/*    private static Singleton instance = new Singleton();
    public static Singleton getInstance() {
        return instance;
    }*/

    //双检锁/双重校验锁
    private volatile static Singleton singleton;

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

    // 静态内部类
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance2() {
        return SingletonHolder.INSTANCE;
    }

    // 枚举
    public enum Singleton33 {
        INSTANCE;

        public void whateverMethod() {
        }
    }
}