单例模式---简单理解

1.什么是单例模式？我们为什么要用单例模式？  

    首先我们要知道我们为什么要用单例模式，其实在很多的时候我们都用到了单例模式，这也是很经常要用到的，比如一个对象我们只需要它实例化一次，不允许它任意的创建。其实这就是单例模式，就是我们要一个对象只实例化一次，比如数据库的   连接。。  

2.单例模式有哪些？  

    常用的单例模式分为两种：一种是懒汉模式，另一种是饿汉模式。  

3.怎么理解这两种常用的单例模式？  

（1）饿汉模式：其实就是先实例化我们需要创建的单例对象。 

    ---饿坏了，迫不及待的想吃东西，就叫做饿汉模式。 

（2）懒汉模式：当我们需要用到单例对象的时候再实例化。 

    ---你不用，我就不实例化。 

但是总的来说创建单例模式的基本步骤是一样的：

  步骤如下： 

第一步：实例化该类的构造函数，  

第二步：私有静态化实例对象，保证只在本类执行  

第三步：返回一个共有的函数，返回该实例对象    

4.通过代码来说详细的讲解：  

（1）饿汉模式   

public class HungrySingleTon {  
      
    private static HungrySingleTon instance = new HungrySingleTon();//迫不及待的想吃东西--创建对象  
      
    private HungrySingleTon(){  
          
    }  
      
    public static HungrySingleTon getInstance(){  
        return instance;  
    }  
  
}

（2）懒汉模式 

public class LazySingleTon {  
      
    private static LazySingleTon instance;//很懒啊，不想创建，因为没有用到  
      
    private LazySingleTon(){  
          
    }  
      
    public static LazySingleTon getInstance(){  
        if(instance == null){  
            instance = new LazySingleTon();  
        }  
        return instance;  
    }  
  
}  

5.上面两种各单例模式的“变种”（也是常用的）： 

（1）静态内部类的方法 

public class CommonSingleTon {  
      
    private static class SingleTon{  
        private static CommonSingleTon instance = new CommonSingleTon();  
    }  
    private CommonSingleTon(){  
          
    }  
    public static CommonSingleTon getInstance(){  
        return SingleTon.instance;  
    }  
}

（2）双重检测，线程安全的（但不是保证百分百安全）   

public class SingleTon {  
  
    private volatile static SingleTon instance = null;  
      
    private SingleTon(){}  
      
    public static SingleTon getSingleTonInstance(){  
        if(instance==null){  
            synchronized (SingleTon.class) {  
                if(instance == null){  
                    return instance = new SingleTon();  
                }  
            }  
        }  
            return instance;  
          
          
    }  
  
}

单例模式其实还有很多的变种，比如同步方法，LockL的方法等等，还有枚举的方法，但是都离不开他的概念，