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

使用场景：

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

实现流程：

      (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;
    }

}

       测试结果：

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