23种设计模式之单例模式

//饿汉模式
public class HungrySingleton {
    //利用静态变量来记录singleton的唯一实例
    private final static HungrySingleton uniqueInstance=new HungrySingleton();

    /**
     * 构造器私有化，只有singleton内部才可以调用
     * 确保不会被其他代码实例化
     */
    private HungrySingleton(){
        System.out.println("HungrySingleton is create");
    }

    public static HungrySingleton getInstance(){
        return uniqueInstance;
    }
    //其他角色
    public static void createString(){
        System.out.println("createString in HungrySingleton");
    }

    public static void main(String[] args) {
        HungrySingleton.createString();
    }
}

//线程不安全的懒汉模式
public class NoSafeSingleton {
    //利用静态变量来记录singleton的唯一实例
    private static NoSafeSingleton uniqueInstance;

    /**
     * 构造器私有化，只有singleton内部才可以调用
     * 确保不会被其他代码实例化
     */
    private NoSafeSingleton(){
    }

    //线程不安全
    //第一个线程进来判断 uniqueInstance == null，还没有new 出实例的时候 。
    // 这个时候第二个线程也进来了，判断的uniqueInstance 也是 null，然后也会 new 出实例的
    public static NoSafeSingleton getInstance(){
        if (null==uniqueInstance){
            uniqueInstance=new NoSafeSingleton();
        }
        return uniqueInstance;
    }
}

//线程安全的懒汉模式-实现延迟加载
public class SyncLazySingleton {
	private SyncLazySingleton() {
		System.out.println("SyncLazySingleton is create");
	}

	//instance初始值赋予null，确保系统启动时没有额外的负载
	private static SyncLazySingleton instance = null;

	//使用同步关键字，防止多个实例被创建（多线程环境），synchronized保证线程安全
	public static synchronized SyncLazySingleton getInstance() {
		if (instance == null) {
			instance = new SyncLazySingleton();
		}
		return instance;
	}

	//synchronized保证线程安全，降低了系统性能
	public static void main(String[] args) {
		new Thread(){
			public void run(){
				long bg = System.currentTimeMillis();
				for (int i = 0; i < 1000000; i++) {
//					HungrySingleton.getInstance();
					 SyncLazySingleton.getInstance();
				}
				System.out.println("spend:" + (System.currentTimeMillis() - bg)+"ms");
			}
		}.start();
	}
}

//安全的懒汉模式-使用内部类实现单例 ，实现延迟加载
public class StaticSingleton {
	private StaticSingleton(){
		System.out.println("StaticSingleton is create");
	}

	//JVM加载 StaticSingleton时不会初始化内部类SingletonHolder
	//当方法getInstance()被调用时，才会加载getInstance()
	private static class SingletonHolder{
		private static StaticSingleton instance=new StaticSingleton();
	}

	public static StaticSingleton getInstance(){
		return SingletonHolder.instance;
	}

	public static void main(String[] args) {
		StaticSingleton instance=StaticSingleton.getInstance();
		System.out.println(instance);
	}
}

//序列化和反序列化可能会破坏单例
public class SerSingleton implements Serializable {

	//私有构造器阻止被实例化
	private SerSingleton() {
	}

	private static class SingletonHolder {
		private static final SerSingleton instance = new SerSingleton();
	}

	public static SerSingleton getInstance() {
		return SingletonHolder.instance;
	}

	//序列化和反序列化可能会破坏单例
	//readResolve method to preserve singleton property
	//阻止生成新的实例，总是返回当前对象
	private Object readResolve(){
		//Return the true one SerSingleton and let garbage collector
		// take care of the SerSingleton impersonator.
		return SingletonHolder.instance;
	}

}

//最简洁的单例模式
//无偿地提供了序列化机制，绝对防止多次实例化
public enum SingletonEnum {
    INSTANCE;

    public static void main(String[] args) {
        SingletonEnum singletonEnum = SingletonEnum.INSTANCE;
        SingletonEnum singletonEnum1 = SingletonEnum.INSTANCE;
        
        System.out.println(singletonEnum == singletonEnum1);
        System.out.println(singletonEnum.getClass());
    }
}

	public static final AtomicInteger counter=new AtomicInteger();
	private StaticSingleton(){
		counter.incrementAndGet();
		System.out.println("The "+(counter.get())+" StaticSingleton instance is created");
	}

//利用反射破坏单例模式
public class ReflectSingleton {
	public static void main(String[] args) throws Exception {
		StaticSingleton singleton = StaticSingleton.getInstance();

		Constructor constructor=singleton.getClass().getDeclaredConstructor();

		//值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。
		// 值为 false 则指示反射的对象应该实施 Java 语言访问检查。
		constructor.setAccessible(true);

		StaticSingleton singleton2= (StaticSingleton) constructor.newInstance();
		StaticSingleton singleton3= (StaticSingleton) constructor.newInstance();

		System.out.println("singleton2==singleton3 ："+(singleton2==singleton3));
	}
}

The 1 StaticSingleton instance is created
The 2 StaticSingleton instance is created
The 3 StaticSingleton instance is created
singleton2==singleton3 ：false