Java单例模式及线程安全问题

单例的目的是为了保证运行时Singleton类只有唯一的一个实例，用于一些较大开销的操作。

1. 饿汉方式(线程安全)

	/** 饿汉方式(线程安全) **/
	private Singleton(){}
	private static final Singleton singleton = new Singleton();
	public Singleton getSingleton(){
		return singleton;
	}

由于使用static关键字进行了修饰，只能获取到一个对象，从而达到了单例，并且在Singleton类初始化的时候就创建了对象，加载到了内存。

2. 懒汉方式(3种)

	/** 1.懒汉方式(非线程安全) **/
	private static Singleton singleton = null;
	public Singleton getSingleton(){
		if(null == singleton){
			singleton = new Singleton();
		}
		return singleton;
	}

	/** 2.懒汉方式(线程安全) **/
	private static Singleton singleton = null;
	public synchronized Singleton getSingleton(){
		if(null == singleton){
			singleton = new Singleton();
		}
		return singleton;
	}
	
	/** 3.双重校验，并懒加载(线程安全) **/
	private static volatile Singleton singleton = null;
	public static Singleton getSingleton(){
		if(null == singleton){
			synchronized(Singleton.class){
				if(singleton == null){
					singleton = new Singleton();
				}
			}
		}
		return singleton;
	}

上面的2和3代码看似解决了线程安全问题，也起到了延迟加载的作用，但是双重锁机制是没有办法工作的，有一篇文章解释的非常深刻：http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

在参考了一些资料，我认为双重锁机制之所以不能正常运行是因为，在new对象的时候，是有三个步骤的：分配内存空间，初始化对象，然后将内存地址赋值给变量；在这么三个步骤中，极有可能会在操作上进行重排序，在重排序的情况下，还没有初始化
对象，先将内存地址赋值给了变量（这种情况是可能存在的），当线程B进入时，发现变量不为null，就会直接返回这个实例，然而此时可能拿到的是还没有初始化完成的对象。所以双重锁机制是不提倡使用的。

在http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html#dcl文章中有提出，在新的内存模型下，实例字段使用volatile可以解决双重锁检查的问题，因为在新的内存模型下，volatile禁止了一些重排序，但是，同时，使用volatile的性能开销也有所上升。

所以又提出一种新的模式——Initialization on Demand Holder. 这种方法使用内部类来做到延迟加载对象，在初始化这个内部类的时候，JLS(Java Language Sepcification)会保证这个类的线程安全。代码如下：

	/** 静态内部类方式(线程安全，并且性能最佳) **/
	private static class SingletonHolder{
		static Singleton singleton = new Singleton();
	}
	public static Singleton getSingleton(){
		return SingletonHolder.singleton;
	}