1. 单例模式笔记

主要
- 饿汉式（线程安全，调用效率高，但是，不能延迟加载）
- 懒汉式（线程安全，调用效率不高，但是，可以延迟加载）
其他
- 双重检测琐式（由于JVM底层内部模型原因，偶尔会出问题，不建议使用）
- 静态内部式（线程安全，调用效率高，但是，可以延迟加载）
- 枚举单例（线程安全，调用效率高，但是，不能延迟加载）

如何选用：

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

2. 单例模式的5种实现

2.1 饿汉式（单例对象立即加载）

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

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

}

测试类：

public class Client1 {

	public static void main(String[] args) {
		SingletonDemo1 s1 = SingletonDemo1.getInstance();
		SingletonDemo1 s2 = SingletonDemo1.getInstance();
		System.out.println(s1 == s2);//true
		System.out.println(s1.hashCode()==s2.hashCode());//true
		
	}

}

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

2.2 懒汉式（单例对象延迟加载）

lazy load 延迟加载，懒加载！真正用的时候才加载！

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

}

测试类：

public class Client1 {

	public static void main(String[] args) {
		
		SingletonDemo2 s3 = SingletonDemo2.getInstance();
		SingletonDemo2 s4 = SingletonDemo2.getInstance();
		System.out.println(s3 == s4);//true

	}

}

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

2.3 双重检测锁实现

将同步内容放到if内部，提高了执行的效率，不必每次获取对象时都进行同步，只有第一次才同步，创建了以后就没必要了。

/**
 * 双重检索实现单例模式
 * @author kevin
 *
 */
public class SingletonDemo3 {
	
	private static SingletonDemo3 instance = null;
	
	private SingletonDemo3() {
		
	}
	
	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;
	}

}

测试类：

public class Client1 {

	public static void main(String[] args) {
		
		SingletonDemo3 s5 = SingletonDemo3.getInstance();
		SingletonDemo3 s6 = SingletonDemo3.getInstance();
		System.out.println(s5 == s6);//true
		

	}

}

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

2.4 静态内部类实现方式（单例对象延迟加载）

/**
 * 测试静态内部类实现单例模式
 * @author kevin
 *
 */
public class SingletonDemo4 {
	
	private static class SingletonClassInstance {
		private static final SingletonDemo4 instance = new SingletonDemo4();
	}
	
	private SingletonDemo4() {
		
	}
	
	//方法没有同步，调用效率高
	public static SingletonDemo4 getInstance() {
		return SingletonClassInstance.instance;
	}

}

测试类：

public class Client1 {

	public static void main(String[] args) {
		
		SingletonDemo4 s7 = SingletonDemo4.getInstance();
		SingletonDemo4 s8 = SingletonDemo4.getInstance();
		System.out.println(s7 == s8);//true
		

	}

}

要点：

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

2.5 枚举实现方式

/**
 * 测试枚举实现单例模式
 * @author kevin
 *
 */
public enum SingletonDemo5 {
	
	//这个枚举元素 ，代表了Singleton的一个实例
	INSTANCE;
	
	//添加自己需要的操作
	public void singletonOperation() {
		
	}

}

测试类：

public class Client1 {

	public static void main(String[] args) {
		
		SingletonDemo5 s9 = SingletonDemo5.INSTANCE;
		SingletonDemo5 s10 = SingletonDemo5.INSTANCE;
		System.out.println(s9 == s10);//true
		

	}

}

优点：

实现简单
枚举本身就是单例模式。由jvm从根本上提供保障！避免通过反射和反序列化的漏洞。

缺点：

无延迟加载

3. 反射和反序列化**单例模式

1）反射可以**上面几种单例模式（非枚举式）的实现方式。

可以在构造方法中手动抛出异常控制

2）反序列化可以**上面几种单例模式（非枚举式）实现方式。

可以通过定义readResolve()防止获得不同对象

3.1 反射**单例模式

定义个懒汉式实现的单例模式：

public class SingletonDemo6 {
	
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo6 instance;
	
	private SingletonDemo6(){
		
	}
	
	//方法同步，调用效率低！
	public static synchronized SingletonDemo6 getInstance() {
		if(instance == null) {
			instance = new SingletonDemo6();
		}
		return instance;
	}

}

使用反射**单例模式测试类：Client2.java：

public class Client2 {

	public static void main(String[] args) throws Exception {
		SingletonDemo6 s1 = SingletonDemo6.getInstance();
		SingletonDemo6 s2 = SingletonDemo6.getInstance();
		System.out.println(s1);
		System.out.println(s2);
		
		//通过反射的方式直接调用私有的构造器
		Class clazz = Class.forName("com.stormkai.singleton.demo.SingletonDemo6");
		
		Constructor<SingletonDemo6> c = clazz.getDeclaredConstructor(null);
		c.setAccessible(true);
		
		SingletonDemo6 s3 = c.newInstance();
		SingletonDemo6 s4 = c.newInstance();
		
		System.out.println(s3);
		System.out.println(s4);
		
	}

}

测试结果为：

com.stormkai.singleton.demo.SingletonDemo6@15db9742
com.stormkai.singleton.demo.SingletonDemo6@15db9742
com.stormkai.singleton.demo.SingletonDemo6@6d06d69c
com.stormkai.singleton.demo.SingletonDemo6@7852e922

3.1.1 防止反射**单例模式

只需要在单例的私有构造器中添加如下代码：

if(instance != null) {
    throw new RuntimeException();
}

则反射**单例模式时候就会报java.lang.reflect.InvocationTargetException.

代码如下：

public class SingletonDemo6 {
	
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo6 instance;
	
	private SingletonDemo6(){
		
		//添加如下代码，反射**单例时候会报java.lang.reflect.InvocationTargetException
		if(instance != null) {
			throw new RuntimeException();
		}
		
	}
	
	//方法同步，调用效率低！
	public static synchronized SingletonDemo6 getInstance() {
		if(instance == null) {
			instance = new SingletonDemo6();
		}
		return instance;
	}

}

再次执行Client2.java，测试结果为：

com.stormkai.singleton.demo.SingletonDemo6@15db9742
com.stormkai.singleton.demo.SingletonDemo6@15db9742
Exception in thread "main" java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(Unknown Source)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source)
	at java.lang.reflect.Constructor.newInstance(Unknown Source)
	at com.stormkai.singleton.demo.Client2.main(Client2.java:30)
Caused by: java.lang.RuntimeException
	at com.stormkai.singleton.demo.SingletonDemo6.<init>(SingletonDemo6.java:20)
	... 5 more

3.2 反序列化**单例模式

给单例的实现类SingletonDemo6.java添加序列化implements Serializable

public class SingletonDemo6 implements Serializable {
	
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo6 instance;
	
	private SingletonDemo6(){
		
		//添加如下代码，反射**单例时候会报java.lang.reflect.InvocationTargetException
		if(instance != null) {
			throw new RuntimeException();
		}
		
	}
	
	//方法同步，调用效率低！
	public static synchronized SingletonDemo6 getInstance() {
		if(instance == null) {
			instance = new SingletonDemo6();
		}
		return instance;
	}

}

使用反序列化**单例模式测试类：Client2.java：

public class Client2 {

	public static void main(String[] args) throws Exception {
		SingletonDemo6 s1 = SingletonDemo6.getInstance();
		SingletonDemo6 s2 = SingletonDemo6.getInstance();
		System.out.println(s1);
		System.out.println(s2);
		
		
		//通过反序列化的方式构造多个对象
		FileOutputStream fos = new FileOutputStream("d:/aaa.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(s1);
		oos.close();
		fos.close();
		
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/aaa.txt"));
		SingletonDemo6 s3 = (SingletonDemo6)ois.readObject();
		System.out.println(s3);
		
	}

}

测试结果为：

com.stormkai.singleton.demo.SingletonDemo6@15db9742
com.stormkai.singleton.demo.SingletonDemo6@15db9742
com.stormkai.singleton.demo.SingletonDemo6@776ec8df

3.2.1 防止反序列化**单例模式

反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！

修改单例实现类SingletonDemo6.java

public class SingletonDemo6 implements Serializable {
	
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo6 instance;
	
	private SingletonDemo6(){
		
		//添加如下代码，反射**单例时候会报java.lang.reflect.InvocationTargetException
		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;
	}

}

再次执行Client2.java，测试结果为：

com.stormkai.singleton.demo.SingletonDemo6@15db9742
com.stormkai.singleton.demo.SingletonDemo6@15db9742
com.stormkai.singleton.demo.SingletonDemo6@15db9742

4. 常见的五种模式在多线程环境下的效率测试

测试类：

public class Client3 {

	public static void main(String[] args) throws Exception {
		long start = System.currentTimeMillis();
		int threadNum = 10;
		
		final CountDownLatch countDownLatch = new CountDownLatch(threadNum);
		
		for (int i = 0; i < threadNum; i++) {
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					for(int i=0;i<1000000;i++){
						Object o = SingletonDemo2.getInstance();
						//Object o = SingletonDemo5.INSTANCE;
					}
					
					countDownLatch.countDown();
					
				}
			}).start();
		}
		
		countDownLatch.await();	//main线程阻塞，直到计数器变为0，才会继续往下执行！
		
		long end = System.currentTimeMillis();
		System.out.println("总耗时："+(end-start));

	}

}

CountDownLatch

同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或者多个线程一直等待。

countDown()：当前线程调此方法，则计数减一（建议放在finally里执行）
await()：调用此方法会一直阻塞当前线程，直到计时器值为0

相关标签：单例模式单例模式5种实现方式 **单例模式反射**单例模式反序列化**单例模式

上一篇： C++单例模式的经典实现(Singleton)

下一篇：单例的两种实现方式、多个版本及利弊对照

1. 单例模式笔记

文章目录

1. 单例模式

1.1 核心作用

1.2 常见应用场景

1.3 优点

1.4 常见的五种单例模式实现方法

2. 单例模式的5种实现

2.1 饿汉式（单例对象立即加载）

2.2 懒汉式（单例对象延迟加载）

2.3 双重检测锁实现

2.4 静态内部类实现方式（单例对象延迟加载）

2.5 枚举实现方式

3. 反射和反序列化**单例模式

3.1 反射**单例模式

3.1.1 防止反射**单例模式

3.2 反序列化**单例模式

3.2.1 防止反序列化**单例模式

4. 常见的五种模式在多线程环境下的效率测试

Android源码学习之单例模式应用及优点介绍

谈一谈iOS单例模式

iOS App开发中使用设计模式中的单例模式的实例解析

PHP设计模式之单例模式入门与应用详解

使用设计模式中的Singleton单例模式来开发iOS应用程序

java使用静态关键字实现单例模式

C# 设计模式之单例模式归纳总结

PHP中用Trait封装单例模式的实现

C#中单例模式的三种写法示例

PHP 面向对象程序设计（oop）学习笔记(三) - 单例模式和工厂模式