JAVA_设计模式_创建型_单例模式

单例模式分五种

1. 饿汉式
2. 懒汉式
3. 双重检查锁式
4. 静态内部类式
5. 枚举式

1.饿汉式

package com.bjsxt.singleton;

/**
 * 饿汉式单例模式
 * 线程安全、调用效率高
 * 可能造成资源浪费
 * @author WL20180732
 *
 */
public class SingletonDemo01 {
	
	// 类初始化时立即加载
	private static SingletonDemo01 instance = new SingletonDemo01();
	
	// 构造器私有化
	private SingletonDemo01() {}
	
	// 提供对外访问方法
	public static SingletonDemo01 getInstance() {
		return instance;
	}
	
}

2.懒汉式

package com.bjsxt.singleton;

/**
 * 懒汉式单例模式
 * 线程安全、调用效率相对低
 * @author WL20180732
 *
 */
public class SingletonDemo02 {
	
	// 类初始化时不创建对象，只有等到真正调用的时候才会创建
	private static SingletonDemo02 instance = null;
	
	// 构造器私有化
	private SingletonDemo02() {}
	
	// 提供对外访问方法
	public static synchronized SingletonDemo02 getInstance() {
		if (instance == null) {
			instance = new SingletonDemo02();
		}
		return instance;
	}
	
}

3.双重检查锁式

package com.bjsxt.singleton;

/**
 * 双重检查锁式单例模式
 * @author WL20180732
 *
 */
public class SingletonDemo03 {
	
	// 类初始化时不创建对象，只有等到真正调用的时候才会创建
	private static SingletonDemo03 instance = null;
	
	// 构造器私有化
	private SingletonDemo03() {}
	
	// 提供对外访问方法
	public static SingletonDemo03 getInstance() {
		if (instance == null) {
			synchronized (SingletonDemo03.class) {  //两个线程同时到达此处
				if (instance == null) {
					instance = new SingletonDemo03();
				}
			}
		}
		return instance;
	}
	
}

4.静态内部类式

package com.bjsxt.singleton;

/**
 * 静态内部类式单例模式
 * 线程安全，调用效率高，并且实现了延时加载
 * @author WL20180732
 *
 */
public class SingletonDemo04 {
	
	// 静态内部类只有在外部类使用它的时候才会初始化，因此实现延时加载，类里面的静态变量在类初始化时创建，因此保证单例
	private static class SingletonClassInstance {
		private static final SingletonDemo04 instance = new SingletonDemo04();
	}
	// 构造器私有化
	private SingletonDemo04() {}
	
	// 提供对外访问方法
	public static SingletonDemo04 getInstance() {
		return SingletonClassInstance.instance;
	}
	
}

5.枚举式

package com.bjsxt.singleton;

/**
 * 枚举式单例模式
 * 枚举本身就是单例模式
 * 线程安全，调用效率高，并且实现了延时加载
 * @author WL20180732
 * 避免了反射和反序列化的漏洞
 * 没有延时加载
 */
public enum SingletonDemo05 {
	
	// 这个枚举元素本身就是单例对象
	INSTANCE;
	
	// 添加自己需要的操作
	public void SingletonOperation() {
		
	}
}

6.测试反射和反序列化破解懒汉式单例模式

package com.bjsxt.singleton;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;

/**
 * 测试反射和反序列化破解懒汉式单例模式
 * @author WL20180732
 *
 */
public class Client2 {

	public static void main(String[] args) throws Exception {
		SingletonDemo06 s1 = SingletonDemo06.getInstance();
		SingletonDemo06 s2 = SingletonDemo06.getInstance();
		System.out.println(s1);
		System.out.println(s2);
		
		// 通过反射的方式直接调用私有构造器
		/*Class<SingletonDemo06> clazz = 
				(Class<SingletonDemo06>) Class.forName("com.bjsxt.singleton.SingletonDemo06");
		Constructor<SingletonDemo06> c = clazz.getDeclaredConstructor(null);  // 获得私有无参构造
		c.setAccessible(true);  // 跳过检查
		
		// 破解单例
		SingletonDemo06 s3 = c.newInstance();
		SingletonDemo06 s4 = c.newInstance();
		
		System.out.println(s3);
		System.out.println(s4);*/
		
		// 通过反序列化的方式构造多个对象
		FileOutputStream fos = new FileOutputStream("E:/mycode/aa.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(s1);
		oos.close();
		fos.close();
		
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:/mycode/aa.txt"));
		SingletonDemo06 s5 = (SingletonDemo06) ois.readObject();
		System.out.println(s5);  // s5 != s1
		
	}
	
	
}

7.测试懒汉式单例模式，如何防止反射和反序列化漏洞

package com.bjsxt.singleton;

import java.io.ObjectStreamException;
import java.io.Serializable;

/**
 * 测试懒汉式单例模式，如何防止反射和反序列化漏洞
 * @author WL20180732
 * 避免了反射和反序列化的漏洞
 * 没有延时加载
 */
public class SingletonDemo06 implements Serializable{
	
	// 类初始化时不创建对象，只有等到真正调用的时候才会创建
	private static SingletonDemo06 instance = null;
	
	// 构造器私有化
	private SingletonDemo06() {
		if (instance != null) {
			throw new RuntimeException();  // 防止通过反射破解单例
		}
		
	}
	
	// 提供对外访问方法
	public static synchronized SingletonDemo06 getInstance() {
		if (instance == null) {
			instance = new SingletonDemo06();
		}
		return instance;
	}
	
	/**
	 * 防止通过反序列破解单例
	 * @return
	 * @throws ObjectStreamException
	 */
	private Object readResolve() throws ObjectStreamException {
		return instance;
	}
}

8.测试多线程环境下五种单例模式的创建效率

package com.bjsxt.singleton;

import java.util.concurrent.CountDownLatch;

/**
 * 测试多线程环境下五种单例模式的创建效率
 * @author WL20180732
 *
 */
public class Client3 {
	public static void main(String[] args) throws InterruptedException {
		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 <100000; i++) {
//						Object o = SingletonDemo01.getInstance();
//						Object o = SingletonDemo02.getInstance();
//						Object o = SingletonDemo03.getInstance();
//						Object o = SingletonDemo04.getInstance();
						Object o = SingletonDemo05.INSTANCE;
					}
					countDownLatch.countDown();
				}
			}).start();
		}
		
		countDownLatch.await();  // main线程阻塞，直到计数器变为0，才会继续往下执行
		long end = System.currentTimeMillis();
		System.out.println("总耗时：" + (end - start));
	}
}