单例模式二

上一篇简单的介绍了单例模式，及实现的步骤；实际使用过程中却会出现一个严重的错误，例如高并发的消息中心管理类我们套用上述模式，出现了多个实例；简要分析就可以定位到 多次并发创建singleton时起始都是为null的，singleton == null的方式并不能保证线程安全。于是有了下面三种线程安全的单例实现

本篇主要介绍单例的三种实现：饿汉式，懒汉式，IoDH

（一）饿汉式

/**
 * 饿汉式单例模式
 * 
 * @author zhubo
 *
 */
public class EagerSingleton {
	
	/** 静态的类型变量**/
	private static final EagerSingleton eagerSingleton = new EagerSingleton();
	
	/** 私有的构造方法 **/
	private EagerSingleton(){
		
	}
	/** 公有的静态方法 **/
	public static EagerSingleton newInstance(){
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return eagerSingleton;
	}
	
	private String name;//私有变量 名字
	public void setName(String name){
		this.name = name;
	}
	public void sayName(){ //公有方法  sayName
		System.out.println("EagerSingleton 对象的名字："+name+"  "+this);
	}
}

在定义静态变量的时候实例化单例类，因此在类加载的时候就已经创建了单例对象；

并发测试调用

/**
 * 并发饿汉式测试
 * @author zhubo
 *
 */
public class EagerSingletonMain {
	private static int length = 13;//次数
	
	public static void main(String[] args) throws InterruptedException {
		ExecutorService executor = Executors.newCachedThreadPool();
		final CountDownLatch latchM = new CountDownLatch(length);
		for(int i=0;i<length;i++){
			Runnable runnable = new Runnable(){  
                public void run(){  
                    try {
                    	latchM.await(100,TimeUnit.MILLISECONDS);
                    	EagerSingleton eagerSingleton = EagerSingleton.newInstance();
                    	eagerSingleton.setName("Hello "+Thread.currentThread().getName());
                    	eagerSingleton.sayName();
                    } catch (Exception e) {
                        e.printStackTrace();  
                    } finally {
                    	latchM.countDown();
                    }  
                }  
            };  
            executor.execute(runnable);//为线程池添加任务
		}
		if(executor!=null){  
            executor.shutdown();  
        }  
	}
}

打印的对象实例地址是一样的

（二）懒汉式

它不会在类加载时就自行创建对象，可以理解为一种延迟加载，只有调用时才加载实例。lazySingleton == null 采用了双重检查锁定方式。下面探究下这是为什么呢？

其实在并发初始化对象实例时，初始多个线程的lazySingleton都为null，虽然我们添加了synchronized同步但当一个线程初始化完成后，其他线程并不知道对象已经创建，就会再创建一次，造成了多个实例的情况；所以我们在同步代码块仍要做为空判断。并发测试代码可以参考饿汉式测试代码

/**
 * 懒汉式单例模式
 * @author zhubo
 *
 */
public class LazySingleton {
	
	/** 静态的类型变量**/
	private  static LazySingleton lazySingleton = null;
	/** 私有的构造方法 **/
	private LazySingleton(){
		
	}
	/** 公有的静态方法 **/
	public static LazySingleton newInstance(){
		if(lazySingleton == null){
			synchronized (LazySingleton.class) {
				if(lazySingleton == null){
					try {
						Thread.sleep(3000);//模拟长时间的初始化
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					lazySingleton = new  LazySingleton();
				}
			}
		}
		return lazySingleton;
	}
	private String name;//私有变量 名字
	public void setName(String name){
		this.name = name;
	}
	public void sayName(){ //公有方法  sayName
		System.out.println("LazySingleton 对象的名字："+name+"  "+this+"  "+ new Date());
	}

（三）IoDH
很明显地饿汉式和懒汉式各有特点，但他们也都有不足之处。

饿汉式在类加载时就创建对象，一定程度上虚耗了内存，在资源利用率上它不及懒汉式，

懒汉式实现了延迟加载，多线程处理时需要同步代码块控制，在多线程调用一些消耗系统资源管理类时，资源管理类的缺点是显著的，系统性能会受到影响。

下面有一种更好的实现：

/**
 * IoDH单例模式
 * 
 * @author zhubo
 *
 */
public class IoDHSingleton {

	/** 私有的构造方法 **/
	private IoDHSingleton(){
		
	}
	/** 公有的静态方法 **/
	public static IoDHSingleton newInstance(){
		return LazyHolder.ioDHSingleton;
	}
	/**私有 静态的内部类**/
	private static class LazyHolder{
		
		private static final IoDHSingleton ioDHSingleton = new IoDHSingleton();
	}
	private String name;//私有变量 名字
	public void setName(String name){
		this.name = name;
	}
	public void sayName(){ //公有方法  sayName
		System.out.println("IoDHSingleton 对象的名字："+name+"  "+this);
	}
}

描述(实现依赖于由Java语言规范（JLS）规定的Java虚拟机（JVM）中的执行的初始化阶段)，分三个部分描述：

(1)JVM加载时，因为类IoDHSingleton没有任何静态变量来初始化，所以初始化完成；其中的静态类定义LazyHolder不会初始化，直到JVM确定必须执行LazyHolder。

(2)静态类LazyHolder只有在静态方法newInstance在类IoDHSingleton上被调用时才被执行，并且第一次发生这种情况时，JVM将加载并初始化LazyHolder类。

(3)LazyHolder类的初始化导致静态变量ioDHSingleton通过执行外部类IoDHSingleton的（private）构造函数来初始化。由于类初始化阶段由JLS保证是串行的，即非并发的，在加载和初始化期间在静态newtInstance方法中不需要进一步的同步。由于初始化阶段在串行操作中写入静态变量ioDHSingleton，因此newInstance的所有后续并发调用都将返回相同的正确初始化的ioDHSingleton，而不会产生任何额外的同步开销。

虽然实现了一个没有同步开销的高效的线程安全的“单例”高速缓存，并且比无竞争同步具有更好的性能，但是只有在确保IoDHSingleton的构造不会失败时，才能使用该习语。在大多数JVM实现中，如果IoDHSingleton的构造失败，随后从相同的类加载器初始化它的尝试将抛出NoClassDefFoundError异常。