单例的各种写法以及双重检查的问题详解编程语言

一、懒汉式，线程不安全

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

具有Lazy-Loading，但是多线程下不安全

二、懒汉式，线程安全

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

三、饿汉式

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

基于classloder机制避免了多线程的同步问题，让instance实例在类装载时就实例化
缺点：
1. 但是这样子没有Lazy-Loading的效果，如果Instance的初始化很大，效率会很低
2. 如果instance的创建需要依赖参数或者是配置文件，将无法使用

四、静态内部类

public class Singleton {   
    private static class SingletonHolder {   
    private static final Singleton INSTANCE = new Singleton();   
    }   
    private Singleton (){}   
    public static final Singleton getInstance() {   
    return SingletonHolder.INSTANCE;   
    }   
}  

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，但是这种也是有Lazy-Loading的效果的，因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance

五、双重检查

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

为什么要加volatile？

我们来考虑一下，不加volatile的情况：

singleton = new Singleton();

这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。

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

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2，（也就是不存在happen-before）；
如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。

解决：使用volatile

volatile可以禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。
加了volatile之后，此时存在volatile的happen-before原则：

volatile写操作一定先行于volatile的读操作

比如上面的例子，当singleton加上了volatile之后，new Singleton()是一个写操作，所以执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况，这样就是一个安全的单例了

五、最简单，最好的单例：枚举

public enum Singleton {   
    INSTANCE;   
    public void whateverMethod() {   
    }   
}  

这种方式的好处是：
1. 利用的枚举的特性实现单例
2. 由JVM保证线程安全
3. 序列化和反射攻击已经被枚举解决

扩展

1、如何防止单例被反射破坏？
思路：设置一个flag，让它创建第二个实例时，抛出异常
http://blog.csdn.net/u013256816/article/details/50525335

2、序列化破坏反射如何避免？
http://www.importnew.com/18030.html