GoF23 单例模式学习笔记

GoF23 单例模式学习笔记

单例模式：构造即私有

饿汉式

package single;

// 饿汉式单例：天生线程安全
// 问题是可能会消耗不必要的内存
public class Hungry {

	private Hungry() {

	}

	private final static Hungry HUNGRY = new Hungry();

	public Hungry getInstance() {
		return HUNGRY;
	}

}

懒汉式

package single;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

// 懒汉式单例
public class LazyMan {
	
	private static boolean secret = false;

	private LazyMan() {
		synchronized (LazyMan.class) {
			if(!secret) {
				secret = true;
			}else {
				throw new RuntimeException("Bad Guy");
			}
		}
	}

	private volatile static LazyMan LAZYMAN;

	// 双重检测锁模式 的 懒汉式单例 DCL懒汉式
	public static LazyMan getInstance() {
		if (LAZYMAN == null) {
			synchronized (LazyMan.class) {
				if (LAZYMAN == null) {
					LAZYMAN = new LazyMan();
					/**
					 * 不是原子性操作
					 * 
					 * 1. 分配内存空间 2. 执行构造方法，初始化对象 3. 把这个对象指向该内存空间
					 * 
					 * 有可能出现指令重排现象
					 * 
					 * 线程A执行132，线程B会认为LAZYMAN不等于null，直接走return LAZYMAN，此时LAZYMAN还没有完成构造和初始化
					 * 因此必须加volatile
					 * volatile不能保证原子性，但能保证不发生指令重排
					 */
				}
			}
		}
		return LAZYMAN;
	}
	
	// 反射破坏
	public static void main(String[] args) throws Exception {
//		LazyMan instance = LazyMan.getInstance();
		Field secret = LazyMan.class.getDeclaredField("secret");
		secret.setAccessible(true);
		
		Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor();
		constructor.setAccessible(true);
		LazyMan reflectInstance1 = constructor.newInstance();
		
		secret.set(reflectInstance1, false);
		
		LazyMan reflectInstance2 = constructor.newInstance();
		System.out.println(reflectInstance1.hashCode());
		System.out.println(reflectInstance2.hashCode());
	}
}

静态内部类（不安全）

package single;

public class Holder {

	private Holder() {

	}

	public static Holder getInstance() {
		return innerClass.HOLDER;
	}

	public static class innerClass {
		private static final Holder HOLDER = new Holder();
	}
}

枚举类型

package single;

import java.lang.reflect.Constructor;

public enum EnumSingle {
	INSTANCE;
	public EnumSingle getInstance() {
		return INSTANCE;
	}

	public static void main(String[] args) throws Exception {
		Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
		declaredConstructor.setAccessible(true);
		EnumSingle instance = declaredConstructor.newInstance();
		System.out.println(EnumSingle.INSTANCE);
		System.out.println(instance);
	}
}

为什么枚举类型可以防止反射破坏？
反编译后发现类的修饰abstract，不能创建实例，反射也无能为力