一、懒汉式，线程不安全
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 件事情。
给 instance 分配内存调用 Singleton 的构造函数来初始化成员变量将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
