🎨 05. 싱글턴 패턴

🍫 하나뿐인 특별한 객체 만들기, 싱글턴 패턴

고작 객체 인스턴스 1개 만드는 방법을 1개 장에 걸쳐서 배운다고요?

싱글턴 패턴은 특정 클래스에 객체 인스턴스가 하나만 만들어지도록 해 주는 패턴이다. 싱글턴 패턴을 사용하면 전역 변수를 사용할 때와 마찬가지로 객체 인스턴스를 어디서든지 액세스할 수 있게 만들 수 있으며, 전역 변수를 쓸 때의 단점(애플리케이션이 끝날 때까지 한 번도 쓰지 않는 -괜히 자원만 잡아먹는- 쓸데없는 객체가 생기는 문제 등)을 감수할 필요도 없다. 싱글턴 패턴을 사용하면 필요할 때만 객체를 만들 수 있기 때문이다.

“어떻게 하면 한 클래스의 인스턴스를 두 개 이상 만들지 않게 하지?”

🍫 고전적인 싱글턴 패턴 구현법

public class Singleton {
    // 고정된 단 하나의 인스턴스를 저장하는 정적 변수
    private static Singleton uniqueInstance = null;

    // 외부에서 new Singleton() 하지 못하도록 생성자를 private으로 선언
    private Singleton() {
        // 생성자 내부 로직
    }

    // 외부에서 인스턴스를 가져가는 유일한 방법
    public static Singleton getInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }

    // 기타 메소드
}

라인	설명
private static uniqueInstance	이 클래스의 유일한 인스턴스를 저장하는 정적 변수. null로 초기화해서 아직 생성되지 않았음을 나타냄.
private Singleton()	생성자를 private으로 선언해서 외부에서 new Singleton()을 하지 못하게 함. 오직 클래스 내부에서만 생성 가능.
static getInstance()	인스턴스를 생성하거나 반환하는 메서드. 인스턴스가 없으면 새로 만들고, 있으면 기존 것을 반환.

핵심 요약:

• 외부에서 직접 인스턴스를 만들 수 없게 하고
• 내부에서 단 한 번만 생성되도록 제한
• 언제든 동일한 객체에 접근 가능하도록 static 메서드로 노출

🎤 패턴 집중 인터뷰 - 싱글턴 객체의 심경 고백

인터뷰 요약:

• 나는 프로그램에서 단 하나뿐인 객체다
  • 레지스트리 설정이 담겨 있는 객체가 여러 개 있다면 서로 다른 설정 내역도 여러 개 있다는 말이 된다. 하지만 싱글턴을 사용하면 한 애플리케이션에 들어있는 어떤 객체에서도 같은 자원을 활용할 수 있다.
• 나를 만들기 위해 생성자를 private으로 숨겼음
  • public으로 지정된 생성자가 없다 = 외부에서 인스턴스를 생성할 수 없도록 private 생성자만 존재한다.
• 단 하나의 인스턴스만 가지도록 철저히 통제되어 있음
  • 클래스가 인스턴스를 오직 하나만 생성하게 만들고, 다른 경로로는 절대로 새 인스턴스를 만들 수 없도록 강제한다.
  • 싱글턴 객체가 필요한 경우 new Singleton() 같은 방식으로 새로운 객체를 만들지 못하게 하고, getInstance()라는 정적 메소드를 호출한다.

🍫 초콜릿 보일러 코드 살펴보기

요즘은 대다수의 초콜릿 공장에서 초콜릿을 끓이는 장치(이하 ‘초콜릿 보일러’로 지칭)를 컴퓨터로 제어한다. 초콜릿 보일러는 초콜릿과 우유를 받아서 끓이고 초코바를 만드는 단계로 넘겨준다. 아래에는 최신형 초콜릿 보일러를 제어하는 클래스가 나와 있다.

초콜릿 공장에서 사용하는 장치인 초콜릿 보일러는 다음의 순서를 따라 작동한다.

1. 초콜릿과 우유를 채운다
2. 보일러를 가열해 끓인다
3. 다 끓은 재료를 다음 공정인 초코바 만들기로 넘긴다

다음과 같은 실수는 막는다.

• 아직 끓지 않은 재료 500갤런을 그냥 흘려 버린다. ❌
• 보일러가 가득 차 있는 상태에서 새로운 재료를 붓는다. ❌
• 빈 보일러를 끓인다. ❌

public class ChocolateBoiler {
    private boolean empty;
    private boolean boiled;

    public ChocolateBoiler() {
        empty = true;
        boiled = false;
    }

    public void fill() {
        if (isEmpty()) {
            empty = false;
            boiled = false;
        }
    }

    public void boil() {
        if (!isEmpty() && !isBoiled()) {
            boiled = true;
        }
    }

    public void drain() {
        if (!isEmpty() && isBoiled()) {
            empty = true;
        }
    }

    public boolean isEmpty() {
        return empty;
    }

    public boolean isBoiled() {
        return boiled;
    }
}

하지만 2개의 ChocolateBoiler 인스턴스가 따로 돌아가면 상당히 안 좋은 상황이 일어날 수 있다.\만약 한 애플리케이션에서 ChocolateBoiler 인스턴스가 2개 이상 만들어지면 어떤 문제가 생길 수 있을까?

🍫 싱글턴 패턴의 정의

싱글턴 패턴(Singleton Pattern)은 클래스 인스턴스를 하나만 만들고, 그 인스턴스로의 전역 접근을 제공한다.

• 싱글턴 패턴을 실제로 적용할 때는 클래스에서 하나뿐인 인스턴스를 관리하도록 만들면 된다. 그리고 다른 어떤 클래스에서도 자신의 인스턴스를 추가로 만들지 못하게 해야 한다. 인스턴스가 필요하다면 반드시 클래스 자신을 거치도록 해야한다.
• 어디서든 그 인스턴스에 접근할 수 있도록 전역 접근 지점을 제공한다. 언제든 이 인스턴스가 필요하면 클래스에 요청할 수 있게 만들어 놓고, 요청이 들어오면 그 하나뿐인 인스턴스를 건네주도록 만들어야 한다.

🔹 static uniqueInstance

• 싱글턴 객체를 클래스 수준에서 저장하는 정적 변수
• 딱 하나의 인스턴스를 저장해 놓음

🔹 static getInstance()

• 싱글턴의 핵심 메서드
• Singleton.getInstance()라는 코드만 사용하면 언제 어디서든 이 메소드를 호출할 수 있음
• 게으른 인스턴스를 생성할 수 있다는 장점 (= 필요할 때까지 객체를 만들지 않는다)

🍫 초콜릿 보일러에 문제 발생

고전적인 싱글턴 패턴으로 코드를 고쳤음에도 ChocolateBoiler에 있는 fill() 메소드에서 아직 초콜릿이 끓고 있는데 새로운 재료를 넣고 말았다. 멀티스레드를 사용하도록 초콜릿 보일러 컨트롤러를 최적화시켰을 뿐인데…!

Step 1. Thread 1이 getInstance()를 호출함

• uniqueInstance가 null인지 확인 → true
• Thread 1은 인스턴스를 생성하려고 함

Step 2. 동시에 Thread 2도 getInstance()를 호출함

• uniqueInstance가 여전히 null (Thread A가 아직 생성 안 끝냄)
• Thread 2도 인스턴스 생성

결과: 인스턴스가 두 번 생성됨

• Thread 1 → Singleton 인스턴스 1 생성
• Thread 2 → Singleton 인스턴스 2 생성

왜 문제냐?

싱글턴은 하나만 있어야 하는데, 동시에 만들어서 두 개가 되어버린 거

• 프로그램이 전역에서 같은 객체를 공유할 거라고 믿고 사용하는데
• 알고 보니 각자 다른 걸 쓰고 있음 → 버그 발생 가능

🍫 멀티스레딩 문제 해결하기

getInstance()를 동기화하면 멀티스레딩과 관련된 문제가 간단하게 해결된다.

public static synchronized Singleton getInstance() {
    if (uniqueInstance == null) {
        uniqueInstance = new Singleton();
    }
    return uniqueInstance;
}

synchronized 키워드를 추가하게 되면 한 스레드가 메소드 사용을 끝내기 전까지 다른 스레드는 기다려야 한다. 즉, 2개의 스레드가 이 메소드를 동시에 실행하는 일은 일어나지 않는다.

이러면 문제가 해결되긴 하겠지만, 동기화할 때 속도 문제가 생기지 않나요?

맞음.

그리고 조금 더 생각해보면 사실 동기화가 꼭 필요한 시점은 이 메소드가 시작되는 때뿐이라는 사실을 알 수 있다. 굳이 이 메소드를 동기화된 상태로 유지할 필요가 없다. 즉, 처음을 제외하면 동기화는 불필요한 오버헤드만 증가시킬 뿐이다.

🍫 더 효율적으로 멀티스레딩 문제 해결하기

방법 1

getInstance()의 속도가 그리 중요하지 않다면 그냥 둔다.

방법 2

인스턴스가 필요할 때는 생성하지 말고 처음부터 만듭니다.

애플리케이션에서 Singleton의 인스턴스를 생성하고 계속 사용하거나 인스턴스를 실행 중에 수시로 만들고 관리하기가 성가시다면 다음과 같은 방법을 적용해 보자.

• 정적 초기화 부분에서 Singleton의 인스턴스를 생성한다. 이러면 스레드를 써도 별 문제가 없다.

class Singleton {
  private static instance: Singleton = new Singleton(); // 애초에 만들어 놓음

  private constructor() {}

  public static getInstance(): Singleton {
    return this.instance;
  }
}

방법 3

‘DCL’을 써서 getInstance()에서 동기화되는 부분을 줄입니다.

Double-Checked Locking, DCL을 사용하면 인스턴스가 생성되어 있는지 확인한 다음 생성되어 있지 않았을 때만 동기화할 수 있다. 이러면 처음에만 동기화하고 나중에는 동기화하지 않아도 된다.

• volatile 키워드를 사용하면 멀티스레딩을 쓰더라도 uniqueInstance 변수가 Singleton 인스턴스로 초기화되는 과정이 올바르게 진행된다.

public class Singleton {
  private volatile static Singleton uniqueInstance;

  private Singleton() {}

  public static Singleton getInstance() {
  // 인스턴스가 있는지 확인하고, 없으면 동기화된 블록으로 들어감
    if (uniqueInstance == null) {
      synchronized(Singleton.class) {
        if (uniqueInstance == null) {
          uniqueInstance = new Singleton();
        }
      }
    }
    return uniqueInstance;
  }
}

🍫 문제를 해결하는 적절한 방법 선택하기

1. synchronized 방식 (동기화된 메서드)

public class ChocolateBoiler {
    private boolean empty;
    private boolean boiled;

    private static ChocolateBoiler uniqueInstance;

    // 생성자는 private – 외부에서 new 못 하게 막음
    private ChocolateBoiler() {
        empty = true;
        boiled = false;
    }

    // getInstance()에 synchronized 붙여서 스레드 하나만 접근 가능
    public static synchronized ChocolateBoiler getInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new ChocolateBoiler();
        }
        return uniqueInstance;
    }

    public void fill() {
        if (isEmpty()) {
            empty = false;
            boiled = false;
        }
    }

    public void boil() {
        if (!isEmpty() && !isBoiled()) {
            boiled = true;
        }
    }

    public void drain() {
        if (!isEmpty() && isBoiled()) {
            empty = true;
        }
    }

    public boolean isEmpty() {
        return empty;
    }

    public boolean isBoiled() {
        return boiled;
    }
}

✅ 장점

• 멀티스레드 환경에서 안전

  여러 스레드가 동시에 접근해도 단 하나의 인스턴스만 생성

• 구현이 단순

❌ 단점

• 매번 락을 걸기 때문에 성능 저하가 발생할 수 있음
• 특히 인스턴스가 이미 만들어진 이후에도 getInstance()를 호출할 때마다 락을 거는 건 낭비

2. 이른 초기화 (Eager Initialization)

public class ChocolateBoiler {
    private boolean empty;
    private boolean boiled;

    // 인스턴스를 애초에 만들어버림 (JVM 로딩 시점에)
    private static final ChocolateBoiler uniqueInstance = new ChocolateBoiler();

    private ChocolateBoiler() {
        empty = true;
        boiled = false;
    }

    public static ChocolateBoiler getInstance() {
        return uniqueInstance;
    }

    public void fill() {
        if (isEmpty()) {
            empty = false;
            boiled = false;
        }
    }

    public void boil() {
        if (!isEmpty() && !isBoiled()) {
            boiled = true;
        }
    }

    public void drain() {
        if (!isEmpty() && isBoiled()) {
            empty = true;
        }
    }

    public boolean isEmpty() {
        return empty;
    }

    public boolean isBoiled() {
        return boiled;
    }
}

✅ 장점

• 코드가 가장 간단하고, 멀티스레드 안전
• 클래스가 로딩될 때 인스턴스가 딱 한 번 만들어지고 끝
• 이후 접근 속도가 빠르다. 락이 필요 X

❌ 단점

• 쓰든 안 쓰든 무조건 인스턴스를 만들기 때문에 메모리 낭비 가능
• 인스턴스를 만드는 데 시간이 오래 걸리는 경우, 앱 로딩 지연 발생 가능

3. Double-Checked Locking (이중 검사 잠금)

public class ChocolateBoiler {
    private boolean empty;
    private boolean boiled;

    // volatile: 스레드 간 메모리 일관성 보장
    private volatile static ChocolateBoiler uniqueInstance;

    private ChocolateBoiler() {
        empty = true;
        boiled = false;
    }

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

    public void fill() {
        if (isEmpty()) {
            empty = false;
            boiled = false;
        }
    }

    public void boil() {
        if (!isEmpty() && !isBoiled()) {
            boiled = true;
        }
    }

    public void drain() {
        if (!isEmpty() && isBoiled()) {
            empty = true;
        }
    }

    public boolean isEmpty() {
        return empty;
    }

    public boolean isBoiled() {
        return boiled;
    }
}

✅ 장점

• 최초 한 번만 락을 걸기 때문에 성능이 좋다.
• 멀티스레드 환경에서도 안전하고, 이미 인스턴스가 만들어졌으면 락 없이 빠르게 리턴됨

❌ 단점

• 구현이 가장 복잡하다.
• 실수하면 멀티스레드 버그가 생길 수 있음
• 자바 1.4 이하에서는 volatile 문제로 완전히 안전하지 않음 (요즘엔 대부분 괜찮)

✨ 언제 뭘 써야 할까?

• 성능보다 단순한 코드가 중요하면 → synchronized
• 인스턴스를 무조건 쓸 거고 빠른 속도가 필요하면 → eager
• 정말 효율이 중요한 멀티스레드 환경이면 → DCL

🍫 방금 깨달았는데요…

enum을 사용하면 싱글턴의 여러 문제점을 해결할 수 있을 것 같아요.

좋은 생각입니다!

지금까지 우리가 했던 Singleton 클래스를 만들고 동기화하는 일은 싱글턴이 어떻게 작동하는지 확실히 이해하려고 한 것이고, 싱글턴이 필요할 때면 바로 enum을 쓰면 된다.

🧠 왜 enum으로 싱글턴을 만들면 좋을까?

자바에서 enum은 언어 차원에서 단 하나의 인스턴스만 생성되도록 보장한다. 자바 컴파일러와 JVM이 내부적으로 멀티스레딩 안전성까지 보장해 주기 때문에, 특히 멀티스레딩 + 직렬화 문제까지 한 번에 해결해야 할 경우enum 싱글턴은 매우 강력한 선택이다!

public enum ChocolateBoiler {
    INSTANCE; // 단 하나의 인스턴스 (Singleton)

    private boolean empty = true;
    private boolean boiled = false;

    public void fill() { ... }
    public void boil() { ... }
    public void drain() { ... }
}