public class SimpleSingleton {
	private static SimpleSingleton instance; // SimpleSingleton class 에서 instance 를 미리 안만들기로 함.

	private SimpleSingleton() {} // private contructor

	/**
	 * 다음과 같은 singleton method 는 문제가 있다. 바로 thread-safe 하지 않다는 것!!!
	 * 1. thread1, thread2 가 if 에 동시에 접근하고, 현재 instance field 는 null 이기에 둘 다 접근!!
	 * 2. thread1 이 new keyword 로 SimpleSingleton class 생성. 이제 instance field 는 null 이 아니다
	 * 3. thread2 도 new keyword 로 SimpleSingleton class 생성. 이제 ...? 아까 instance 는 null 아니었는데...?
	 * '이미 if 안에 들어온 시점에서 instance == null' 이었기에 thread2 도 instance 를 생성하게 된 것.
	 */
	public static SimpleSingleton getInstance() { // instance를 제공하기 위해 만든 method
		if (instance == null) {
			instance = new SimpleSingleton();
		}
		return instance;
	}
}

public class SynchronizedSingleton {
	private static SynchronizedSingleton instance;

	private SynchronizedSingleton() {}

	/**
	 * multi-threading 환경에서도 하나의 instance 만 생성됨을 보장할 수 있다.
	 * 그러나 getInstance method 를 호출할 때 마다 동기화 처리하는 작업 때문에 성능에 영향을 미칠 수 있다.
	 */
	public static synchronized SynchronizedSingleton getInstance() {
		if (instance == null) {
			instance = new SynchronizedSingleton();
		}
		return instance;
	}
}

public class DoubleCheckedLockingSingleton {
	private static volatile DoubleCheckedLockingSingleton instance; // field volatile 선언

	private DoubleCheckedLockingSingleton() {}

	public static DoubleCheckedLockingSingleton getInstance() {
		if (instance == null) { // 1번째 확인
			synchronized (DoubleCheckedLockingSingleton.class) { // class lock 사용
				if (instance == null) { // 2번째 확인
					instance = new DoubleCheckedLockingSingleton(); // 1,2 번째 확인 후 생성안되어 있었다면, instance생성
				}
			}
		}

		return instance;
	}
}

public class EagerSingleton {
	/**
	 * 동기화 keyword 를 사용하는건 성능적으로 안좋을 것 같아서 multi-thread 환경에서도 안전한 '미리선언하는 방법' 을 사용.
	 * INSTANCE 는 class loading 할 때에 초기화되어 미리 생성된다.
	 * 이 방법의 단점은 '미리 생성' 한다는 것이다.
	 * 만약 EagerSingleton class 가 생성하는데 많은 비용이 든다면,
	 * 필요하지도 않을 때 큰 비용을 들여가며 instance 를 생성할 필요가 있는지 생각을 해봐야 한다.
	 */
	private static final EagerSingleton INSTANCE = new EagerSingleton(); // EagerSingleton class 에서 instance 를 미리 만들기로 함.

	private EagerSingleton() {}

	public static EagerSingleton getInstance() {
		return INSTANCE;
	}
}

public class StaticInnerClassSingleton {
	private StaticInnerClassSingleton() {}

	/**
	 * 장점
	 * 1. multi-threading 환경에서도 안전하다.
	 * 		왜? : JVM 에서는 class loading 할 때 안전한 동기화 환경을 제공하기 때문이다.
	 * 		따라서 Holder 라는 inner class 가 loading 될 때, 그 과정 자체가 JVM 에서 동기화 환경을 제공하니깐 thread-safe 하게
	 * 		INSTANCE 를 생성할 수 있는 것.
	 * 2. Lazy loading 이 가능하다.
	 * 		StaticInnerClassSingleton class 가 로딩되는 시점이 아닌, getInstance() method 를 호출할 때에
	 * 		INSTANCE 객체가 생성되므로 우리가 원하는 시점에 생성핳 수 있다는 장점이 있다.
	 *
	 * Double Checked Locking 과 같이 복잡한 이론이나, 코드가 필요없이 간단하게 만들 수 있다.
	 */
	
	// 2. Holder class loading.
	private static class Holder {
		// 3. class loading 되면서 static field 가 초기화 되는데 그 때 JVM 에서 동기화 환경을 제공한다.
		// 		→ 따라서 thread-safe 하다고 할 수 있다.
		private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
	}

	public StaticInnerClassSingleton getInstance() {
		return Holder.INSTANCE; // 1. Holder class 호출.
	}
}

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

/**
 * 만약에 제공하는 사람은 singleton 으로 잘 제공했는데 쓰는 사람이 이상하게 쓴다면...?
 * singleton 을 깨트리는 방법에 대해 알아보자
 */
public class ReflectionConstructor {
	public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
		StaticInnerClassSingleton singleton = StaticInnerClassSingleton.getInstance();

		Constructor<StaticInnerClassSingleton> constructor = StaticInnerClassSingleton.class.getDeclaredConstructor();
		constructor.setAccessible(true); // private constructor 에 접근 true 하게 만들기
		StaticInnerClassSingleton instance = constructor.newInstance(); // 새로운 instance 생성

		System.out.println("singleton == reflection instance : " + (singleton == instance));
		// singleton == reflection instance : false
	}
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

/**
 * 이 실험을 위해서 SingletonClass 를 생성. 
 * SingletonClass : StaticInnerClass 와 똑같이 구현됐다.
 * test 를 위해서는 SingletonClass 에서 Serializable 을 implements 해야 한다.
 */
public class Serializing {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		SingletonClass singleton = SingletonClass.getInstance();
		SingletonClass instance = null;

		// singleton object 를 file 에 저장 : serialization
		try (ObjectOutput out = new ObjectOutputStream(new FileOutputStream("singleton.obj"))) {
			out.writeObject(singleton);
		}

		// file 에 저장된 객체를 read : deserialization
		// 이 때 생성자를 사용하여 instance 를 만들어주기 때문에 다른 instance 가 나오는 것이다.
		try (ObjectInput in = new ObjectInputStream(new FileInputStream("singleton.obj"))) {
			instance = (SingletonClass) in.readObject();
		}

		System.out.println("serialization object : " + singleton);
		System.out.println("deserialization object : " + instance);
		/*
		serialization object : javastudy.designpattern.singleton.brokepattern.SingletonClass@234bef66
		deserialization object : javastudy.designpattern.singleton.brokepattern.SingletonClass@7c16905e
		 */
	}
}

public enum ReflectionPreventSingleton {
	INSTANCE
}

import java.io.Serializable;

public class SerializationSolutionSingleton implements Serializable {
	private SerializationSolutionSingleton() {}

	private static class Holder {
		private static final SerializationSolutionSingleton INSTANCE = new SerializationSolutionSingleton();
	}

	public static SerializationSolutionSingleton getInstance() {
		return SerializationSolutionSingleton.Holder.INSTANCE;
	}

	/**
	 * 해당 method 를 정의해주게 되면, deserialization 할 때에 읽어서 instance 를 새로 생성하는게 아니라
	 * getInstance() 로 주기 때문에 같은 instance 를 반환받을 수 있게 된다.
	 */
	protected Object readResolve() {
		return getInstance();
	}
}