设计模式（二）单例模式（创建型）

使用场景：

       一个类只能创建一个实例对象。如读取服务器配置文件的类，由单个实例对象直接读取。

实现流程：

      (1)、定义一个私有变量；

      (2)、将构造函数私有化；

      (3)、提供一个获取实例的公用方法；

     下面列出几种常见的实现模式，仅供参考：

      饿汉式单例：在类创建的时候就初始化实例对象，每次调用的时候都是获取同一对象实例，是线程安全的。

      实现类：

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

}

      测试类：

public class HungrySingletonTest {
	
	private class MyThread extends Thread{
		
		@Override  
		public void run(){
			System.out.println(HungrySingleton.getInstance().hashCode());
		}
		
	}
	
	public static void main(String[] args) {  
		MyThread[] mts = new MyThread[10];  
        for(int i = 0 ; i < mts.length ; i++){  
            mts[i] = new HungrySingletonTest().new MyThread();  
        }  
          
        for (int j = 0; j < mts.length; j++) {  
            mts[j].start();  
        }  
	}

}

      测试结果：

        从测试结果可以看出，该方式是线程安全的。

        普通懒汉式单例:创建类的时候不实例化对象，在调用获取实例方法的时候才创建对象。是线程不安全的。

        实现类：

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

}

         测试类：

public class LazySingletonTest {
	
    private class MyThread extends Thread{
		
		@Override  
		public void run(){
			System.out.println(LazySingleton.getInstance().hashCode());
		}
		
	}
    
    public static void main(String[] args) { 
		MyThread[] mts = new MyThread[10];  
        for(int i = 0 ; i < mts.length ; i++){  
            mts[i] = new LazySingletonTest().new MyThread();  
        }  
          
        for (int j = 0; j < mts.length; j++) {  
            mts[j].start();  
        }  
	}

}

        测试结果：

     从测试结果可以看出，该方式是线程不安全的。

      对线程不安全的懒汉式单例模式，有多种的解决方案。简单的如：在获取实例的公共方法里加上同步标识符synchronized。这样的话可以保证在多线程的环境下获取的实例是唯一的，但也相应地影响了效率。这里列举一种常规的解决方案——Double Check Locking双检查锁机制。

     双检查锁机制（DCL）

     实现类：

public class DclSingleton {
	
	//使用volatile保证线程间可见性
	private static volatile DclSingleton instance = null;
	
	private DclSingleton(){};
	
	public static  DclSingleton getInstance(){
		if(instance == null){
			synchronized(DclSingleton.class){
				//二次检查
				if(instance == null){
					instance = new DclSingleton();
				}
			}
		}
		return instance;
	}

}

       测试结果：

    从测试结果可以看出，该方式是线程安全的，且将同步的范围限制到了最小。是推荐的一种单例实现方式。