单例模式【构建模式】

public class SingleTon {

	/**
	 * 单例模式：
	 * Ensure a class has only one instance,and provide a global point of access to it.
	 * 确保某个类只有一个实例，并提供一个全局访问点来访问该类实例。
	 */
	@Test
	public void all() {
		assertEquals(Eager.instance(), Eager.instance());
		assertEquals(DoubleCheckLock.instance(), DoubleCheckLock.instance());
		assertEquals(StaticInnerClass.instance(), StaticInnerClass.instance());
		assertEquals(SingleEnum.INSTANCE, SingleEnum.INSTANCE);
	}
}

// 恶汉式单例
class Eager {
	/**
	 * 1）确保该对象自行实例化，并只创建一个类实例。
	 */
	private static final Eager EAGER = new Eager();
	private boolean created = false;
	/**
	 * 2）阻止外部类直接创建该类的实例
	 */
	private Eager() {
		// 防止通过反射调用
		if (created) {
			throw new IllegalStateException("allread created");
		}

		created = true;
	}

	/**
	 * 3）提供一个全局访问点
	 */
	public static final Eager instance() {
		return EAGER;
	}
}

// 基于双重检验锁实现延时加载的单例模式
@Slf4j
class DoubleCheckLock {
	private static DoubleCheckLock INSTANCE;

	private DoubleCheckLock() {
		if (INSTANCE != null) {
			throw new IllegalStateException("allready created");
		}
	}

	public static final DoubleCheckLock instance() {
		/**
		 * 第一次判断避免不必要的同步操作
		 */
		if (null == INSTANCE) {
			/**
			 * 第二次判断，只在其为 null 时才创建，多个线程可能阻塞在该阶段，避免重复创建。
			 */
			synchronized (DoubleCheckLock.class) {
				if (null == INSTANCE) {
					log.info("DoubleCheckLock 执行初始化 {}", Thread.currentThread().getName());
					INSTANCE = new DoubleCheckLock();
				}
			}
		}
		return INSTANCE;
	}
}

// 基于静态内部类实现的单例
@Slf4j
class StaticInnerClass {
	private StaticInnerClass() {
	}

	/**
	 * 只有在需要使用时，才执行初始化，既可以延时加载，又可以避免不必要的判断和同步。
	 *
	 * created by ZXD at 23 Dec 2018 T 10:45:15
	 * Keep it simple and stupid
	 */
	private static class Holder {
		private static StaticInnerClass INSTANCE;
		static {
			log.info("StaticInnerClass 执行初始化 {}", Thread.currentThread().getName());
			INSTANCE = new StaticInnerClass();
		}
	}

	public static final StaticInnerClass instance() {
		return Holder.INSTANCE;
	}
}

// 基于枚举实现单例，不可通过反射创建实例，但是不具有延时加载特性。
enum SingleEnum {
	INSTANCE;
}