并发模式下的单例创建

[size=medium]单例模式的创建 分为很多种，这里就不一一列举，这里简单分析一下单例模式的效率和线程安全性。
传统的单例模式是[/size]

   package thread;

public class SingletoDemo {

	public static SingletoDemo instance = null;
	/**
	 * 私有化
	 */
	private SingletoDemo(){}

	public static SingletoDemo getInstance(){
		if(instance == null){
			instance = new SingletoDemo();
		}
		return instance;
	}
}

[size=medium] 为了 实现 线程安全性，出现了如下的 进化[/size]

      package thread;

public class SingletoDemo {

	public static SingletoDemo instance = null;
	/**
	 * 私有化
	 */
	private SingletoDemo(){}

	public static synchronized SingletoDemo getInstance(){
		if(instance == null){
			instance = new SingletoDemo();
		}
		return instance;
	}
}

[size=medium] 但是上面代码的开销 有点不合适，因为每个线程 都会来判断锁。所以 出现了 双重判定。[/size]

   package thread;

public class SingletoDemo {

	public static SingletoDemo instance = null;
	/**
	 * 私有化
	 */
	private SingletoDemo(){}

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

[size=medium] 但是 判断锁 还是存在的，如果我们仅仅是需要在 一种比较合理的，没有特殊情况发生的环境下 创建单例，是不是有那么一种方法，不需要出现判断锁的呢?(这里所说的 特殊情况是指，通过反射机制，强行调用私有构造函数，创建多个实例，还有一种情况就是 序列化和反序列化(通过串行方式))
假定我们假设以上的情况是不多见或者说 在我们的程序当中是不存在不会发生的，那么我们的代码可以有如下实现。[/size]

   package thread;

public class SingletoDemo {

	public static class InnerSingletoDemo{
		public static InnerSingletoDemo instance = new InnerSingletoDemo();

		public static InnerSingletoDemo getInstance(){
			return InnerSingletoDemo.instance;
		}
	}
}

[size=medium]通过代码 我们可以观察出，这段代码是通过内部类的形式 来实现单例的。
在这实现中，单例模式通过内部类来维护单例的实例，当SingletoDemo 外部类被加载 时，
其内部类并不会被初始化，故可以确保外部类被载入jvm时，其内部类不会被初始化，当getInstance()方法被调用时，才会加载内部类从而初始化单例对象，
由于实例的创建是在类加载时完成，因此天生对多线程友好，所以可以省去synchronized关键字。

使用内部类实现单例，既可以实现延迟加载，又可以省去synchronized关键字实现同步，是一种比较完善的实现方式。

但是 我们必须注意上面所说的 特殊情况。[/size]