单例设计模式

单例设计模式

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。

实现：

1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。

2. 在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型。

3. 定义一个静态方法返回这个唯一对象。

单例设计模式特点：

1. 单例类只能有一个实例
2. 单例类必须自己创建自己的唯一实例
3. 单例类必须给所有其他对象提供这一对象实例

分类：

1. 懒汉式
   特点：
   1.1 懒汉式单例在第一次调用的时候初始化
   1.2 懒汉式单例是线程不安全的，在并发的情况下，可能出现多个Singleton实例
   1.3 要实现线程安全需要对getInstance()进行改造，以确保线程安全。

   懒汉式三种方式确保线程安全的方法：
   a. 第一种改造方案 ： 将方法设为同步

   public synchronized static Singleton_lazy  getInstance1(){
   
   if(mSingleton_lazy == null){
   	mSingleton_lazy = new Singleton_lazy() ;
   }
   return mSingleton_lazy ;
   

   }
   b. 双重检查锁定 (比第一中效率要高)（jdk1.5以后才能有效）

   public static Singleton_lazy getInsance2(){
   
   if(mSingleton_lazy == null ){
   	synchronized (Singleton_lazy.class) {
   		if(mSingleton_lazy == null){
   			mSingleton_lazy = new Singleton_lazy() ;
   		}
   	}
   }
   return mSingleton_lazy ;
   

   }
   c. 静态内部类，这种既实现了线程安全，又避免了同步带来的性能影响。

   public  static Singleton_lazy getInstance3(){
   	return LazyHolder.instance ;
   }
   
   private static class LazyHolder{
   	private static final Singleton_lazy  instance = new Singleton_lazy();
   }
   

2. 饿汉式

   特点:

   2.1. 饿汉式单例在类初始时已经实例化
   2.2.线程安全(饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。)

   public class Singleton_hunger {
   //  饿汉式单例在类初始化的时候完成实例化
   private static  final  Singleton_hunger mIntance = new Singleton_hunger();
   
   	// 私有构造函数
   	private Singleton_hunger(){
   
   	}
   
   	public static Singleton_hunger getInstance() {
   	return mIntance;
   	}
   
   }
   

3. DCL双检查锁机制（DCL：double checked locking）

      public class Singleton {
   
      // 将自身实例化对象设置为一个属性，并用static修饰
   	private static Singleton instance;
   
    // 构造方法私有化
    private Singleton() {}
   
     // 静态方法返回该实例
      public static Singleton getInstance() {
    // 第一次检查instance是否被实例化出来，如果没有进入if块
   if(instance == null) {
      synchronized (Singleton.class) {
          // 某个线程取得了类锁，实例化对象前第二次检查instance是否已经被实例化出来，如果没有，才最终实例出对象
          if (instance == null) {
              instance = new Singleton();
          }
      }
      }
      return instance;
    }
   }
   

饿汉式和懒汉式区别

1. 饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。
2. 饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的1、2、3，这三种实现在资源加载和性能方面有些区别。
3. 饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成，而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。