设计模式（17）单例模式

一、介绍：

1、定义：确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例。

2、结构图：

public class Single {
  private static Single single=new Single();
  private Single(){
	  
  }
  public static Single getInstence(){
	  return single;
  }
}



//客户端
public static void main(String[] args) {
	Single single1=Single.getInstence();
	Single single2=Single.getInstence();
	System.out.println(single1==single2);
  }

输出true

3、单例模式有三种实现写法：

（1）饿汉式：静态初始化的方法，类一加载就实例化对象，所以要提前占用系统资源。

public class SingleDemo {
	private static SingleDemo demo = new SingleDemo();

	private SingleDemo() {

	}

	public static SingleDemo getInstance() {	
		return demo;
	}
}

（2）懒汉式：懒汉式单例在第一次调用 getInstance() 方法时实例化，在类加载时并不实例化，这种技术称为延迟加载(Lazy load)。这种方式不会提前占用系统资源，但是存在线程安全问题，当多线程同时访问getInstance方法时，是有可能创建多个实例的。

public class SingleDemo {
	private static SingleDemo demo = null;

	private SingleDemo() {

	}

	public static SingleDemo getInstance() {
		if (demo == null) {
			demo = new SingleDemo();
		}
		return demo;
	}
}

（3）静态内部类实现单例模式：推荐方法，在后面介绍。 

4、懒汉模式的双重检查锁定：先看下为什么要双重锁定。

（1）使用synchronized 关键字

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

（2）第一步，在 getInstance() 方法前加了关键字进行线程锁定来处理多个线程访问的问题。但是每次方法调用时都需要进行线程锁定判断，导致性能大大降低。因此可以对上述代码进行改进，无须对整个 geInstance() 方法锁定，只需对代码块 instance = new LazySingleton() 锁定即可。

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

（3）第二步貌似解决了线程安全问题，但事实并非如此，还是会存在创建多个单例对象的情况：假如线程A和线程B都在调用 getInstance() 方法，此时 instance 对象为 null，两个均能通过 if 判断语句。假如线程A拿到了类锁执行实例创建，线程B处于排队等待，当线程A执行完毕后，线程B并不知道实例已经创建，将继续创建实例，导致产生多个单例对象。

（4）进一步修改代码，在 synchronized 中再进行一次判断，这种方式称为双重锁定检查。

public class LazySingleton {
  // volatile关键字，确保变量修改对其他线程可见
  private volatile static LazySingleton instance = null;
  private LazySingleton() {}
  
  public static LazySingleton getInstance() {
    // 第一重判断
    if (instance == null) {
      synchronized(LazySingleton.class) {
        // 第二重判断
        if (instance == null) {
          instance = new LazySingleton();
        }
      }
    }
    return instance;
  }
}

5、静态内部类实现单例模式：饿汉式单例类在类加载时就实例化，不管用不用始终占用内存；懒汉式单例类线程安全控制繁琐，性能受到影响；饿汉式和懒汉式单例都存在一些问题，为了克服这些问题，在 Java 中可以通过 Initialization on Demand Holder(IoDH) 技术来实现。在 IoDH 中，需要在单例类中新增一个静态内部类，在该内部类创建单例对象。

public class Singleton {
  private Singleton() {}
  
  private static class HoldClass {
    private final static Singleton instance = new Singleton();
  }
  
  public static Singleton getInstance() {
    return HoldClass.instance;
  }
}

由于静态单例对象不是 Singleton 的成员变量，因此在加载 Singleton 类时不会将其实例化，第一次调用 getInstance() 方法时将加载内部类 HoldClass 初始化 instance，由 Java 虚拟机来保证其线程安全性，确保该成员变量只能初始化一次；且由于 getInstance() 方法没有任何线程锁定，因此不会对其性能造成影响。通过 IoDH 既可以实现延迟加载，又可以保证线程安全，不失为一种最好的 Java 语言单例模式的实现方式，其缺点是与编程语言本身的特性有关。