1
2
3
4
5
6
7
8
9
10
11
public final class Elvis {
    public static final Elvis INSTANCE = new Elvis();

    private Elvis() {
        // 리플렉션 공격 방어는 별도로 필요
    }

    public void sing() {
        System.out.println("Thank you, thank you very much.");
    }
}

1
2
3
4
5
6
Constructor<Elvis> c = Elvis.class.getDeclaredConstructor();
        c.setAccessible(true);
        Elvis e1 = c.newInstance();  // 두 번째 인스턴스 생성!
        Elvis e2 = Elvis.INSTANCE;

        System.out.println(e1 == e2);  // false

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public final class Elvis {
    private static final Elvis INSTANCE = new Elvis();

    private Elvis() {
    }

    public static Elvis getInstance() {
        return INSTANCE;
    }

    public void sing() {
        System.out.println("Thank you, thank you very much.");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 호출부는 Elvis.getInstance()로 동일
// 구현 내부만 바뀐다

// 옵션 1: 계속 싱글턴
public static Elvis getInstance() {
        return INSTANCE;
        }

// 옵션 2: 스레드별로 다른 인스턴스 제공 (ThreadLocal)
public static Elvis getInstance() {
        return threadLocal.get();
        }

// 옵션 3: 팩터리가 서브타입을 반환
public static Singer getInstance() {
        return isLegacyMode ? new LegacyElvis() : INSTANCE;
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 메서드 참조로 Supplier 생성 가능
Supplier<Elvis> elvisSupplier = Elvis::getInstance;

// 이를 활용한 DI 구조
public class Concert {
    private final Supplier<Elvis> performer;

    public Concert(Supplier<Elvis> performer) {
        this.performer = performer;
    }

    public void start() {
        performer.get().sing();
    }
}

    // 실제 사용
    Concert concert = new Concert(Elvis::getInstance);

    // 테스트에서는 가짜 객체 주입
    Concert testConcert = new Concert(() -> fakeElvis);

1
2
3
4
5
6
7
8
9
10
11
// 항등 함수(identity function) 싱글턴
@SuppressWarnings("unchecked")
public static <T> UnaryOperator<T> identityFunction() {
        return (UnaryOperator<T>) IDENTITY_FN;
        }

private static final UnaryOperator<Object> IDENTITY_FN = t -> t;

// 사용 시 타입 추론이 동작
        String[] strings = {"a", "b", "c"};
        UnaryOperator<String> sameString = GenericSingleton.identityFunction();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public final class LazyElvis {
    private LazyElvis() {
    }

    // Holder 클래스는 LazyElvis가 로드될 때 함께 로드되지 않는다.
    // getInstance()가 최초로 호출될 때 비로소 로드된다.
    private static class Holder {
        private static final LazyElvis INSTANCE = new LazyElvis();
    }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// DCL 방식 — volatile이 필수지만 실수가 잦다
public class Elvis {
    private volatile static Elvis instance;  // volatile 없으면 버그!

    public static Elvis getInstance() {
        if (instance == null) {
            synchronized (Elvis.class) {
                if (instance == null) {
                    instance = new Elvis();
                }
            }
        }
        return instance;
    }
}

1
2
3
4
5
6
7
8
9
10
public enum Elvis {
    INSTANCE;

    public void sing() {
        System.out.println("Thank you, thank you very much.");
    }
}

// 사용
Elvis.INSTANCE.sing();

1
2
3
4
5
6
7
8
9
10
// 일반 클래스는 뚫린다
Constructor<RegularElvis> c = RegularElvis.class.getDeclaredConstructor();
c.setAccessible(true);
RegularElvis fake = c.newInstance();  // 성공 — 싱글턴 파괴

// enum은 막힌다
Constructor<EnumElvis> ec = EnumElvis.class.getDeclaredConstructor(String.class, int.class);
ec.setAccessible(true);
EnumElvis fake = ec.newInstance("FAKE", 1);  // java.lang.IllegalArgumentException 발생!
// "Cannot reflectively create enum objects"

1
2
3
// OpenJDK Constructor.newInstance() 내부 (단순화)
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
    throw new IllegalArgumentException("Cannot reflectively create enum objects");

1
2
3
4
5
Elvis e1 = Elvis.INSTANCE;
byte[] bytes = serialize(e1);
Elvis e2 = deserialize(bytes);

System.out.println(e1 == e2);  // true — enum은 역직렬화 후에도 동일 인스턴스

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public interface Singer {
    void sing();
}

// enum도 인터페이스는 구현 가능
public enum Elvis implements Singer {
    INSTANCE;

    @Override
    public void sing() {
        System.out.println("Thank you, thank you very much.");
    }
}

// 의존은 인터페이스로 받는다
public class Concert {
    private final Singer performer;

    public Concert(Singer performer) {
        this.performer = performer;
    }
}

// 실제 사용
Concert concert = new Concert(Elvis.INSTANCE);

// 테스트에서는 가짜 객체 주입
Concert testConcert = new Concert(new FakeSinger());

1
2
3
4
5
6
7
8
9
10
11
public final class Elvis {
    public static final Elvis INSTANCE = new Elvis();
    private Elvis() {}
}

// 리플렉션 공격
Constructor<Elvis> constructor = Elvis.class.getDeclaredConstructor();
constructor.setAccessible(true);  // 접근 제어 무시
Elvis newInstance = constructor.newInstance();

System.out.println(Elvis.INSTANCE == newInstance);  // false — 싱글턴 파괴!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public final class GuardedElvis {
    private static final GuardedElvis INSTANCE = new GuardedElvis();
    private static volatile boolean created = false;

    private GuardedElvis() {
        if (created) {
            throw new IllegalStateException("싱글턴 인스턴스는 이미 존재합니다.");
        }
        created = true;
    }

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

1
2
3
4
5
6
Field field = GuardedElvis.class.getDeclaredField("created");
field.setAccessible(true);
field.set(null, false);  // 방어 플래그를 리셋
Constructor<GuardedElvis> c = GuardedElvis.class.getDeclaredConstructor();
c.setAccessible(true);
GuardedElvis fake = c.newInstance();  // 성공

1
2
3
4
5
public class Elvis implements Serializable {
    public static final Elvis INSTANCE = new Elvis();
    private Elvis() {}
    public void sing() {}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Elvis e1 = Elvis.INSTANCE;

// 직렬화
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(e1);
oos.close();

// 역직렬화
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
Elvis e2 = (Elvis) ois.readObject();
ois.close();

System.out.println(e1 == e2);        // false!
System.out.println(e1.equals(e2));   // false! (equals 오버라이드 없으면)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.io.Serial;
import java.io.Serializable;

public final class Elvis implements Serializable {
    @Serial
    private static final long serialVersionUID = 1L;

    private static final Elvis INSTANCE = new Elvis();

    private Elvis() {}

    public static Elvis getInstance() {
        return INSTANCE;
    }

    public void sing() {}

    // 역직렬화 후 반환할 객체를 결정하는 훅 메서드
    @Serial
    private Object readResolve() {
        // 역직렬화로 생성된 객체를 버리고 기존 싱글턴 인스턴스 반환
        return INSTANCE;
    }
}

1
2
3
4
Elvis e1 = Elvis.getInstance();
Elvis e2 = deserialize(serialize(e1));

System.out.println(e1 == e2);  // true — readResolve 덕분에 같은 인스턴스

1
2
3
4
5
6
7
8
9
// 위험한 코드 — 인스턴스 필드가 transient가 아니다
public final class Elvis implements Serializable {
    public static final Elvis INSTANCE = new Elvis();
    private String favoriteSong = "Hound Dog";  // transient가 아님!

    private Object readResolve() {
        return INSTANCE;
    }
}

1
2
3
4
5
6
7
8
public final class Elvis implements Serializable {
    public static final Elvis INSTANCE = new Elvis();
    private transient String favoriteSong = "Hound Dog";  // transient 선언

    private Object readResolve() {
        return INSTANCE;
    }
}

1
2
3
4
5
public class Concert {
    public void start() {
        Elvis.INSTANCE.sing();  // 싱글턴에 강하게 결합
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import java.util.function.Supplier;

public class Concert {
    private final Supplier<Singer> performerSupplier;

    // 구체적인 싱글턴 타입이 아닌 제공자를 받는다
    public Concert(Supplier<Singer> performerSupplier) {
        this.performerSupplier = performerSupplier;
    }

    public void start() {
        Singer performer = performerSupplier.get();
        performer.sing();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
// 정적 팩터리 싱글턴 — 메서드 참조 사용
Concert concert1 = new Concert(Elvis::getInstance);

// 필드 방식 싱글턴 — 람다로 감싸기
Concert concert2 = new Concert(() -> Elvis.INSTANCE);

// enum 싱글턴 — 람다로 감싸기
Concert concert3 = new Concert(() -> EnumElvis.INSTANCE);

// 테스트에서는 가짜 객체 주입
Singer fakeSinger = () -> System.out.println("[FAKE] La la la");
Concert testConcert = new Concert(() -> fakeSinger);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.util.function.Predicate;

// 재사용 가능한 싱글턴 전략들
public final class Predicates {
    private Predicates() {}  // 인스턴스화 방지

    // 싱글턴 Predicate — 한 번만 생성, 계속 재사용
    public static final Predicate<String> HAS_TEXT =
            s -> s != null && !s.isBlank();

    public static final Predicate<String> IS_EMAIL =
            s -> s != null && s.contains("@");

    // 메서드 참조로도 노출
    public static Predicate<String> hasText() {
        return HAS_TEXT;
    }
}

// 사용
List<String> inputs = List.of("hello", "", null, "world");
inputs.stream()
      .filter(Predicates.HAS_TEXT)   // 싱글턴 Predicate 재사용
      .forEach(System.out::println);

// 메서드 참조로 사용
inputs.stream()
      .filter(Predicates::hasText)   // Predicate<String>을 반환하는 메서드 참조
      .forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.util.function.Supplier;

public final class MemoizedSupplier<T> implements Supplier<T> {
    private final Supplier<T> delegate;
    private volatile T value;

    public MemoizedSupplier(Supplier<T> delegate) {
        this.delegate = delegate;
    }

    @Override
    public T get() {
        if (value == null) {
            synchronized (this) {
                if (value == null) {
                    value = delegate.get();
                }
            }
        }
        return value;
    }

    public static <T> Supplier<T> memoize(Supplier<T> supplier) {
        return new MemoizedSupplier<>(supplier);
    }
}

// 사용
Supplier<ExpensiveResource> resource = MemoizedSupplier.memoize(ExpensiveResource::new);
resource.get();  // 이 시점에 처음 생성
resource.get();  // 캐시된 인스턴스 반환