【设计模式】单例模式

1. 核心作用

保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

2. 单例模式的优点

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。
单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

3. 常见的五种单例模式实现方式

3.1 主要

• 饿汉式（线程安全，调用效率高。但是，不能延时加载）
• 懒汉式（线程安全，调用效率不高。但是，可以延时加载）

3.2 其他

• 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
• 静态内部类式（线程安全，调用效率高。可以延时加载）
• 枚举单例（线程安全，调用效率高，不能延时加载）

4. 单例模式Demo

4.1 饿汉式

/**
 * 饿汉式单例模式
 */
public class SingletonDemo01 {
	// 类初始化时立即加载这个对象（没有延时加载的优势）,所以天然线程安全，方法不需要同步
	private static SingletonDemo01 instance = new SingletonDemo01();

	// 私有化构造器
	private SingletonDemo01() {	}

	public static SingletonDemo01 getInstance() {
		return instance;
	}
}

• 问题：若加载此类后并没有使用此对象，则会造成资源的浪费

4.2 懒汉式

/**
 * 懒汉式单例模式
 */
public class SingletonDemo02 {
	// 类初始化时不初始化这个对象，延时加载
	private static SingletonDemo02 instance;

	// 私有化构造器
	private SingletonDemo02() {}

	// 方法同步，调用效率低
	public static synchronized SingletonDemo02 getInstance() {
		if (instance == null) {
			instance = new SingletonDemo02();
		}
		return instance;
	}
}

• 延迟加载 / 懒加载 / lazy load ：调用或使用的时候才加载

• 问题：资源利用率高了。但是，每次调用getInstance()方法都要同步，并发效率较低

4.3 双重检查锁实现

/**
 * 双重检查锁实现单例模式
 */
public class SingletonDemo03 {
	// 类初始化时不初始化这个对象，延时加载
	private static SingletonDemo03 instance = null;

	// 私有化构造器
	private SingletonDemo03() {	}

	// 只有第一次调用时线程同步
	public static SingletonDemo03 getInstance() {
		if (instance == null) {
			SingletonDemo03 sc;
			synchronized (SingletonDemo03.class) {
				sc = instance;
				if (sc == null) {
					synchronized (SingletonDemo03.class) {
						if (sc == null) {
							sc = new SingletonDemo03();
						}
					}
					instance = sc;
				}
			}
		}
		return instance;
	}
}

• 问题：由于编译器优化原因和JVM底层内部模型原因，偶尔会出问题。不建议使用

4.4 静态内部类实现

/**
 * 静态内部类实现单例模式 线程安全，调用效率高，延时加载
 */
public class SingletonDemo04 {
	// 内部类
	private static class SingletonDemo04Inner {
		private static final SingletonDemo04 instance = new SingletonDemo04();
	}

	// 私有化构造器
	private SingletonDemo04() {	}

	public static SingletonDemo04 getInstance() {
		return SingletonDemo04Inner.instance;
	}
}

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

4.5 枚举实现

/**
 * 枚举实现单例模式
 */
public enum SingletonDemo05 {

	// 这个枚举元素本身就是单例对象
	INSTANCE;

	// 添加自己需要的操作
	public void otherMethod() {

	}
}

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

5. 反射、反序列化漏洞

5.1 通过反射获取懒汉式单例对象

/**
 * 单例模式 反射漏洞
 */
public class Client {
	public static void main(String[] args) throws Exception {
		SingletonDemo02 s1 = SingletonDemo02.getInstance();
		SingletonDemo02 s2 = SingletonDemo02.getInstance();
		System.out.println("静态方法获取对象");
		System.out.println(s1);
		System.out.println(s2);
		// 反射获取类
		Class<SingletonDemo02> clazz = (Class<SingletonDemo02>) Class.forName("singleton.SingletonDemo02");
		// 无参构造方法
		Constructor<SingletonDemo02> c = clazz.getDeclaredConstructor(null);
		// 跳过安全检查以获取private类型的私有构造器
		c.setAccessible(true);
		// 实例化对象
		SingletonDemo02 s3 = c.newInstance();
		SingletonDemo02 s4 = c.newInstance();
		System.out.println("反射获取对象");
		System.out.println(s3);
		System.out.println(s4);
	}
}

控制台输出

静态方法获取对象
singleton.SingletonDemo02@15db9742
singleton.SingletonDemo02@15db9742
反射获取对象
singleton.SingletonDemo02@6d06d69c
singleton.SingletonDemo02@7852e922

可见正常获取对象是单例，但利用反射漏洞获取的为非单例

5.1 解决方案

/**
 * 懒汉式单例模式
 */
public class SingletonDemo02 {
	// 类初始化时不初始化这个对象，延时加载
	private static SingletonDemo02 instance;

	// 私有化构造器
	private SingletonDemo02() {
		//若instance不为空则抛出异常
		if (instance != null) {
			throw new RuntimeException();
		}
	}

	// 方法同步，调用效率低
	public static synchronized SingletonDemo02 getInstance() {
		if (instance == null) {
			instance = new SingletonDemo02();
		}
		return instance;
	}
}

控制台输出

静态方法获取对象
singleton.SingletonDemo02@15db9742
singleton.SingletonDemo02@15db9742
Exception in thread "main" java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at singleton.Client.main(Client.java:22)
Caused by: java.lang.RuntimeException
	at singleton.SingletonDemo02.<init>(SingletonDemo02.java:14)
	... 5 more

5.2 通过反序列化获取懒汉式单例对象

前提：SingletonDemo02类实现Serializable接口

/**
 * 单例模式 反序列化漏洞
 */
public class Client {
	public static void main(String[] args) throws Exception {
		SingletonDemo02 s1 = SingletonDemo02.getInstance();
		SingletonDemo02 s2 = SingletonDemo02.getInstance();
		System.out.println("静态方法获取对象");
		System.out.println(s1);
		System.out.println(s2);

		// 反序列化获取多个对象（为了代码的易读，异常一律抛出）
		FileOutputStream fos = null;
		ObjectOutputStream oos = null;
		fos = new FileOutputStream("d:/a.txt");
		oos = new ObjectOutputStream(fos);
		oos.writeObject(s1);
		oos.close();
		fos.close();
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
		SingletonDemo02 s3 = (SingletonDemo02) ois.readObject();
		System.out.println("反序列化方式创建对象");
		System.out.println(s3);
	}
}

控制台输出

静态方法获取对象
singleton.SingletonDemo02@15db9742
singleton.SingletonDemo02@15db9742
反序列化方式创建对象
singleton.SingletonDemo02@776ec8df

5.2 解决方案

/**
 * 懒汉式单例模式
 */
public class SingletonDemo02 implements Serializable {
	// 类初始化时不初始化这个对象，延时加载
	private static SingletonDemo02 instance;

	// 私有化构造器
	private SingletonDemo02() {	}

	// 方法同步，调用效率低
	public static synchronized SingletonDemo02 getInstance() {
		if (instance == null) {
			instance = new SingletonDemo02();
		}
		return instance;
	}

	//反序列化时，若定义了readResolve()方法则直接返回此方法指定的对象，而不需要单独再创建新对象
	private Object readResolve() {
		return instance;
	}
}

控制台输出

静态方法获取对象
singleton.SingletonDemo02@15db9742
singleton.SingletonDemo02@15db9742
反序列化方式创建对象
singleton.SingletonDemo02@15db9742

反射反序列化漏洞对枚举类型不起作用

6. 如何选用

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