单例模式学习笔记

今天写单例模式的时候，发现一个有意思的事情，单例不仅能控制本身的加载情况，还能控制其他类的加载，所以记录一下

1、普通单例

public class SimpleFactory {

	private static SimpleFactory instance = null;
	
	private SimpleFactory() {
		System.out.println("简单的单例工厂方法");
	}
	
	public static SimpleFactory getInstance() {
		if(instance == null) {
			instance = new SimpleFactory();
		}
		return instance;
	}
}

加双重检索之后的单例

public class SimpleFactory {

	private static volatile SimpleFactory instance = null;
	
	private SimpleFactory() {
		System.out.println("简单的单例工厂方法");
	}
	
	public static SimpleFactory getInstance() {
		if(instance == null) {
			synchronized (SimpleFactory.class) {
				if(instance == null) {
					instance = new SimpleFactory();
				}
			}
		}
		return instance;
	}
}

测试情况：

    /**
	 * 测试在单线程下的简单单例工厂方法创建
	 * 结果正常：只会创建一次
	 */
	@Test
	public void testSimpleFactory() {
		for(int i = 0; i < 10; i++) {
			SimpleFactory.getInstance();
		}
	}
	
	/**
	 * 测试在多线程下的简单单例工厂方法创建
	 * 结果失败：会创建多次
	 * 加双重检索机制之后测试成功
	 */
	@Test
	public void testThreadSimpleFactory() {
		for (int i = 0; i < 10; i++) {
			new Thread(() -> {
				SimpleFactory.getInstance();
			}).start();
		}
	}

2、通过单例管理其他类

单例类

public class OtherFactory {

	private static volatile User instance = null;
	
	private OtherFactory() {
		System.out.println("这是OtherFactory构造...");
	}
	
	
	public static User getInstance() {
		if(instance == null) {
			synchronized (User.class) {
				if(instance == null) {
					instance = new User();
				}
			}
		}
		return instance;
	}
}

被管理的user类

public class User {

	private Integer id;
	
	private String name;

	public User() {
		System.out.println("这是User的构造方法...");
	}
}

测试情况：

/**
	 * 测试在单线程下的简单单例工厂方法创建其他类
	 * 测试成功：只会创建一次
	 */
	@Test
	public void testOtherFactory() {
		for(int i = 0; i < 10; i++) {
			OtherFactory.getInstance();
		}
	}

	/**
	 * 测试在多线程下的简单单例工厂方法创建其他类
	 * 结果失败：会创建多次
	 * 加双重检索机制之后测试成功
	 */
	@Test
	public void testThreadOtherFactory() {
		for (int i = 0; i < 1000; i++) {
			new Thread(() -> {
				OtherFactory.getInstance();
			}).start();
		}
	}