设计模式之单例模式

一、初识单例模式

• 核心作用：
  保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
• 常见应用场景：
  – Windows的Task Manager（任务管理器）就是很典型的单例模式
  – windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
  – 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。
  – 网站的计数器，一般也是采用单例模式实现，否则难以同步。
• 单例模式的优点：
  – 由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决
  – 单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理
• 常见的五种单例模式实现方式：
  主要：
  • 饿汉式（线程安全，调用效率高。 但是，不能延时加载。）
  • 懒汉式（线程安全，调用效率不高。 但是，可以延时加载。）
  其他：
  • 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
  • 静态内部类式(线程安全，调用效率高。 但是，可以延时加载)
  • 枚举单例(线程安全，调用效率高，不能延时加载)

二、饿汉式

实例

/**
 * 测试恶汉式单例模式
 */
public class SingletonDemo1 {
	//类初始化时，立即加载这个对象（没有延时加载的优势）。加载类时，天然的是线程安全的
	private static SingletonDemo1 instance = new SingletonDemo1();
	private SingletonDemo1(){}
	//方法没有同步，调用效率高
	public static SingletonDemo1 getInstance(){
		return instance;
	}
}

饿汉式单例模式代码中，static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略synchronized关键字。

问题：如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费！

三、懒汉式

实例

/**
 * 测试懒汉式单例模式
 */
public class SingletonDemo2 {
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo2 instance;
	private SingletonDemo2(){//私有化构造器
	}
	//方法同步调用效率低
	public static synchronized SingletonDemo2 getInstance(){
		if(null==instance){
			instance = new SingletonDemo2();
		}
		return instance;
	}
}

要点：
– lazy load! 延迟加载， 懒加载！ 真正用的时候才加载！
问题：
– 资源利用率高了。但是，每次调用getInstance()方法都要同步，并发效率较低。

四、双重检测锁实现

实例

/**
 * 双重检查锁实现单例模式
 */
public class SingletonDemo3 { 
  private static SingletonDemo3 instance = null; 
  public static SingletonDemo3 getInstance() { 
    if (instance == null) { 
      SingletonDemo3 sc; 
      synchronized (SingletonDemo3.class) { 
        sc = instance; 
        if (sc == null) { 
          synchronized (SingletonDemo3.class) { 
            if(sc == null) { 
              sc = new SingletonDemo3(); 
            } 
          } 
          instance = sc; 
        } 
      } 
    } 
    return instance; 
  } 
  private SingletonDemo3() { }     
}

这个模式将同步内容下方到if内部，提高了执行的效率 不必每次获取对象时都进行同步，只有第一次才同步 创建了以后就没必要了。
问题：
由于编译器优化原因和JVM底层内部模型原因， 偶尔会出问题。不建议使用。

五、静态内部类实现方式(也是一种懒加载方式)

实例

/**
 * 测试静态内部类实现单例模式
 * 这种方式：线程安全，调用效率高，并且实现了延时加载
 */
public class SingletonDemo4 {
	private static class SingletonClassInstance {
		private static final SingletonDemo4 instance = new SingletonDemo4();
	}
	private SingletonDemo4(){}
	//方法没有同步，调用效率高
	public static SingletonDemo4 getInstance(){
		return SingletonClassInstance.instance;
	}
}

外部类没有static属性，则不会像饿汉式那样立即加载对象。
– 只有真正调用getInstance(),才会加载静态内部类。加载类时是线程安全的。 instance是static final 类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性.
兼备了并发高效调用和延迟加载的优势！

六、使用枚举实现单例模式

package singleton;
/**
 * 测试枚举式实现单例模式（没有延时加载）
 */
public enum SingletonDemo5 {
	//这个枚举元素，本身就是单例对象
	INSTANCE;
}

实现简单
– 枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！
缺点：
– 无延迟加载

七、反射和反序列化问题

反射可以破解上面几种(不包含枚举式)实现方式！（可以在构造方法中手动
抛出异常控制）
反序列化可以破解上面几种((不包含枚举式))实现方式！（可以通过定义readResolve()防止获得不同对象。）

import java.io.ObjectStreamException;
import java.io.Serializable;
/**
 * 测试懒汉式单例模式(如何防止反射和反序列化漏洞)
 */
public class SingletonDemo6 implements Serializable {
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo6 instance;  
	private SingletonDemo6(){ //私有化构造器
		if(instance!=null){
			throw new RuntimeException();
		}
	}
	//方法同步，调用效率低！
	public static  synchronized SingletonDemo6  getInstance(){
		if(instance==null){
			instance = new SingletonDemo6();
		}
		return instance;
	}
	//反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！
	private Object readResolve() throws ObjectStreamException {
		return instance;
	}
}

如何选用?
– 单例对象 占用 资源 少，不需要 延时加载：
• 枚举式 好于 饿汉式
– 单例对象 占用 资源 大，需要 延时加载：
• 静态内部类式 好于 懒汉式