[Design Patterns] 05. 싱글톤: 논란이 많은 패턴

 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

// 겉보기에는 단순해 보이는 코드
public class ConfigurationManager {
    private static ConfigurationManager instance;
    private Properties config;
    
    private ConfigurationManager() {
        // 설정 파일 로드
        config = new Properties();
        // ...
    }
    
    public static ConfigurationManager getInstance() {
        if (instance == null) {
            instance = new ConfigurationManager();
        }
        return instance;
    }
    
    public String getProperty(String key) {
        return config.getProperty(key);
    }
}

// 어디서든 쉽게 접근 가능
String dbUrl = ConfigurationManager.getInstance().getProperty("db.url");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// GoF가 제시한 전형적인 사례
public class PrinterSpooler {
    private static PrinterSpooler instance;
    private Queue<PrintJob> jobQueue;
    
    private PrinterSpooler() {
        jobQueue = new LinkedList<>();
    }
    
    public static PrinterSpooler getInstance() {
        if (instance == null) {
            instance = new PrinterSpooler();
        }
        return instance;
    }
    
    public void addJob(PrintJob job) {
        jobQueue.offer(job);
    }
    
    // 물리적으로 하나의 프린터만 존재하므로 여러 인스턴스가 있으면 안 됨
}

 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

// 파일 시스템 접근 관리자
public class FileSystemManager {
    private static FileSystemManager instance;
    private final Map<String, FileLock> lockMap;
    
    private FileSystemManager() {
        lockMap = new ConcurrentHashMap<>();
    }
    
    public static FileSystemManager getInstance() {
        if (instance == null) {
            synchronized (FileSystemManager.class) {
                if (instance == null) {
                    instance = new FileSystemManager();
                }
            }
        }
        return instance;
    }
    
    public boolean acquireLock(String filePath) {
        // 동일한 파일에 대한 중복 락 방지
        return lockMap.putIfAbsent(filePath, new FileLock(filePath)) == null;
    }
}

 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
32
33
34

// 애플리케이션 설정 관리자
public class ApplicationConfig {
    private static volatile ApplicationConfig instance;
    private final Properties properties;
    
    private ApplicationConfig() {
        properties = new Properties();
        loadConfiguration();
    }
    
    public static ApplicationConfig getInstance() {
        if (instance == null) {
            synchronized (ApplicationConfig.class) {
                if (instance == null) {
                    instance = new ApplicationConfig();
                }
            }
        }
        return instance;
    }
    
    private void loadConfiguration() {
        // 설정 파일 로드 - 한 번만 실행되어야 함
        try (InputStream input = getClass().getResourceAsStream("/app.properties")) {
            properties.load(input);
        } catch (IOException e) {
            throw new RuntimeException("Failed to load configuration", e);
        }
    }
    
    public String getProperty(String key) {
        return properties.getProperty(key);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public class EagerSingleton {
    // 클래스 로딩 시점에 인스턴스 생성
    private static final EagerSingleton INSTANCE = new EagerSingleton();
    
    private EagerSingleton() {
        // 생성자에서 복잡한 초기화 작업 수행
        initializeResources();
    }
    
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
    
    private void initializeResources() {
        // 데이터베이스 연결, 파일 로드 등
        System.out.println("Initializing singleton resources...");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public class LazySingleton {
    private static LazySingleton instance;
    
    private LazySingleton() {
        // 필요할 때까지 초기화 지연
        System.out.println("Lazy singleton created");
    }
    
    // synchronized 키워드로 Thread Safety 보장
    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

public class DCLSingleton {
    // volatile 키워드 필수!
    private static volatile DCLSingleton instance;
    
    private DCLSingleton() {
        System.out.println("DCL singleton created");
    }
    
    public static DCLSingleton getInstance() {
        // 첫 번째 체크 - 동기화 블록 진입 최소화
        if (instance == null) {
            synchronized (DCLSingleton.class) {
                // 두 번째 체크 - 실제 인스턴스 생성 보장
                if (instance == null) {
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// JVM이 최적화를 위해 코드 순서를 바꿀 수 있음
// instance = new DCLSingleton(); 는 실제로 3단계:
// 1. 메모리 할당
// 2. 생성자 호출
// 3. instance 변수에 할당

// 2와 3의 순서가 바뀌면 문제 발생!
// Thread A: 메모리 할당 → instance 할당 → 생성자 호출 (진행 중)
// Thread B: instance != null로 판단하고 미완성 객체 사용!

// volatile이 이 문제를 해결함

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class BillPughSingleton {
    private BillPughSingleton() {
        System.out.println("Bill Pugh singleton created");
    }
    
    // 내부 클래스는 getInstance() 호출 시점에 로드됨
    private static class SingletonHelper {
        private static final BillPughSingleton INSTANCE = new BillPughSingleton();
    }
    
    public static BillPughSingleton getInstance() {
        return SingletonHelper.INSTANCE;
    }
}

1
2
3
4
5

// JVM의 클래스 로딩 메커니즘을 영리하게 활용
// 1. BillPughSingleton 클래스 로드 시 SingletonHelper는 로드되지 않음
// 2. getInstance() 호출 시 SingletonHelper 클래스 로드
// 3. 클래스 로더가 Thread Safety 보장
// 4. 지연 초기화 + Thread Safety + 성능 최적화 모두 달성!

 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

public enum EnumSingleton {
    INSTANCE;
    
    private final Properties config;
    
    // Enum 생성자는 private으로 제한됨
    EnumSingleton() {
        config = new Properties();
        loadConfiguration();
    }
    
    public void doSomething() {
        System.out.println("Enum singleton working...");
    }
    
    public String getProperty(String key) {
        return config.getProperty(key);
    }
    
    private void loadConfiguration() {
        // 설정 로드 로직
    }
}

// 사용법
EnumSingleton.INSTANCE.doSomething();
String value = EnumSingleton.INSTANCE.getProperty("key");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 1. 직렬화 안전
// 일반 Singleton은 직렬화/역직렬화 시 새 인스턴스 생성 위험
// Enum은 JVM이 직렬화 시 단일성 보장

// 2. 리플렉션 공격 방지
// 일반 Singleton은 리플렉션으로 private 생성자 호출 가능
try {
    Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
    constructor.setAccessible(true);
    Singleton hackInstance = constructor.newInstance(); // 가능!
} catch (Exception e) {
    // ...
}

// Enum은 리플렉션으로 인스턴스 생성 불가능
try {
    Constructor<EnumSingleton> constructor = EnumSingleton.class.getDeclaredConstructor();
    constructor.setAccessible(true);
    EnumSingleton hackInstance = constructor.newInstance(); // 런타임 에러!
} catch (Exception e) {
    System.out.println("Cannot instantiate enum: " + e.getMessage());
}

 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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Benchmark)
public class SingletonPerformanceBenchmark {
    
    @Benchmark
    public EagerSingleton testEager() {
        return EagerSingleton.getInstance();
    }
    
    @Benchmark
    public LazySingleton testLazy() {
        return LazySingleton.getInstance();
    }
    
    @Benchmark
    public DCLSingleton testDCL() {
        return DCLSingleton.getInstance();
    }
    
    @Benchmark
    public BillPughSingleton testBillPugh() {
        return BillPughSingleton.getInstance();
    }
    
    @Benchmark
    public EnumSingleton testEnum() {
        return EnumSingleton.INSTANCE;
    }
}

/*
JMH 벤치마크 예시 결과 (나노초/operation):
※ 아래 수치는 경향을 보여주기 위한 예시값이다. 절대값은 JVM 버전·하드웨어·
   JIT 워밍업 상태에 따라 크게 달라지므로, 위 벤치마크 코드를 직접 실행해
   자신의 환경에서 측정할 것.

구현 방식               | 평균 시간 | 표준편차 | Throughput
Eager Initialization   |    2.1   |   ±0.1  |  매우 높음
Bill Pugh Solution     |    2.3   |   ±0.1  |  매우 높음
Enum Singleton         |    1.8   |   ±0.1  |  가장 높음
Double-Checked Locking |    2.7   |   ±0.2  |  높음
Lazy Synchronized      |   45.2   |   ±2.1  |  낮음 (병목!)

결론(환경과 무관하게 유지되는 경향):
- 동기화 없는 방식(Enum/Eager/Bill Pugh)은 초기화 후 오버헤드가 거의 없음
- 매 호출 synchronized(Lazy Synchronized)만 수십 배 느림 — 락 경합이 원인
- 초기화 후에는 나머지 방식 간 차이가 미미함
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 겉보기에는 깔끔해 보이는 코드
public class OrderService {
    public void processOrder(Order order) {
        // 숨겨진 의존성들!
        String dbUrl = ConfigManager.getInstance().getDbUrl();
        Logger logger = LoggerManager.getInstance();
        PaymentGateway gateway = PaymentGatewayFactory.getInstance().getGateway();
        
        logger.log("Processing order: " + order.getId());
        
        // 비즈니스 로직
        gateway.processPayment(order.getPayment());
        
        logger.log("Order processed successfully");
    }
}

// 문제점 분석:
// 1. 의존성이 명시되지 않음 - 메서드 시그니처만 보고는 알 수 없음
// 2. 테스트 시 Mock 객체 주입 불가능
// 3. 설정 변경이 전역적으로 영향
// 4. 코드 추적이 어려움

 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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

// 테스트하기 어려운 Singleton 의존 코드
public class EmailService {
    public void sendEmail(String to, String subject, String body) {
        EmailConfig config = EmailConfig.getInstance();
        SmtpClient client = SmtpClient.getInstance();
        
        Email email = new Email(to, subject, body);
        email.setFrom(config.getFromAddress());
        
        client.send(email);
    }
}

// 테스트 코드 - 문제가 많음
@Test
public void testSendEmail() {
    // 문제 1: Singleton 상태 초기화 어려움
    EmailConfig.reset(); // 이런 메서드가 있다면...
    SmtpClient.reset();  // 하지만 보통 없음!
    
    // 문제 2: Mock 객체 주입 불가능
    // Mockito 3.4+의 mockStatic()으로 static 메서드 mocking이 가능해졌지만,
    // try-with-resources로 스코프를 관리해야 하고 테스트가 장황해짐 —
    // "가능하다"와 "설계가 좋다"는 다른 문제
    
    // 문제 3: 테스트 간 격리 실패
    // 이전 테스트의 상태가 영향을 줄 수 있음
    
    EmailService service = new EmailService();
    service.sendEmail("test@example.com", "Test", "Body");
    
    // 검증도 어려움 - Mock이 없으면 실제 이메일이 발송됨!
}

// 더 나은 설계
public class TestableEmailService {
    private final EmailConfig config;
    private final SmtpClient client;
    
    // 의존성 주입
    public TestableEmailService(EmailConfig config, SmtpClient client) {
        this.config = config;
        this.client = client;
    }
    
    public void sendEmail(String to, String subject, String body) {
        Email email = new Email(to, subject, body);
        email.setFrom(config.getFromAddress());
        client.send(email);
    }
}

// 테스트 코드 - 깔끔함
@Test
public void testSendEmail() {
    // Mock 객체 생성
    EmailConfig mockConfig = mock(EmailConfig.class);
    SmtpClient mockClient = mock(SmtpClient.class);
    
    when(mockConfig.getFromAddress()).thenReturn("noreply@example.com");
    
    // 테스트
    TestableEmailService service = new TestableEmailService(mockConfig, mockClient);
    service.sendEmail("test@example.com", "Test", "Body");
    
    // 검증
    verify(mockClient).send(any(Email.class));
}

 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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// 단일 JVM에서만 작동하는 Singleton
public class DistributedCacheManager {
    private static DistributedCacheManager instance;
    private final Map<String, Object> cache;
    
    private DistributedCacheManager() {
        cache = new ConcurrentHashMap<>();
    }
    
    public static DistributedCacheManager getInstance() {
        if (instance == null) {
            instance = new DistributedCacheManager();
        }
        return instance;
    }
    
    public void put(String key, Object value) {
        cache.put(key, value);
    }
    
    public Object get(String key) {
        return cache.get(key);
    }
}

// 문제점:
// 1. 서버 A의 캐시와 서버 B의 캐시가 다를 수 있음
// 2. 로드 밸런싱 환경에서 데이터 불일치
// 3. 마이크로서비스 간 상태 공유 불가능
// 4. 수평 확장 시 각 인스턴스마다 별도의 "싱글톤"

// 더 나은 접근법: 외부 캐시 시스템 사용
@Service
public class RedisBasedCacheManager {
    private final RedisTemplate<String, Object> redisTemplate;
    
    public RedisBasedCacheManager(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    
    public void put(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }
    
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }
}

 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

// 물리적으로 하나만 존재하는 리소스
public class HardwareManager {
    private static HardwareManager instance;
    
    private HardwareManager() {
        // 하드웨어 초기화
        initializeGPU();
        initializeSensors();
    }
    
    public static synchronized HardwareManager getInstance() {
        if (instance == null) {
            instance = new HardwareManager();
        }
        return instance;
    }
    
    public void controlMotor(int speed) {
        // 물리적 모터 제어 - 동시에 여러 명령이 오면 안 됨
    }
    
    public SensorData readSensors() {
        // 센서 데이터 읽기
        return new SensorData();
    }
}

 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
32
33
34
35

// 상태가 없는 유틸리티 클래스
public class MathUtils {
    private static final MathUtils INSTANCE = new MathUtils();
    
    private MathUtils() {}
    
    public static MathUtils getInstance() {
        return INSTANCE;
    }
    
    public double calculateDistance(Point p1, Point p2) {
        double dx = p1.getX() - p2.getX();
        double dy = p1.getY() - p2.getY();
        return Math.sqrt(dx * dx + dy * dy);
    }
    
    public double calculateArea(double radius) {
        return Math.PI * radius * radius;
    }
}

// 하지만 이런 경우는 static 메서드가 더 적합할 수 있음
public class BetterMathUtils {
    private BetterMathUtils() {} // 인스턴스화 방지
    
    public static double calculateDistance(Point p1, Point p2) {
        double dx = p1.getX() - p2.getX();
        double dy = p1.getY() - p2.getY();
        return Math.sqrt(dx * dx + dy * dy);
    }
    
    public static double calculateArea(double radius) {
        return Math.PI * radius * radius;
    }
}

 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
32
33
34
35
36
37
38
39
40

// 로깅 시스템 - 실제로 많이 사용되는 패턴
public class ApplicationLogger {
    private static volatile ApplicationLogger instance;
    private final PrintWriter logWriter;
    private final String logFilePath;
    
    private ApplicationLogger() {
        this.logFilePath = "application.log";
        try {
            this.logWriter = new PrintWriter(new FileWriter(logFilePath, true));
        } catch (IOException e) {
            throw new RuntimeException("Failed to initialize logger", e);
        }
    }
    
    public static ApplicationLogger getInstance() {
        if (instance == null) {
            synchronized (ApplicationLogger.class) {
                if (instance == null) {
                    instance = new ApplicationLogger();
                }
            }
        }
        return instance;
    }
    
    public synchronized void log(String level, String message) {
        String timestamp = LocalDateTime.now().toString();
        logWriter.println(String.format("[%s] %s: %s", timestamp, level, message));
        logWriter.flush();
    }
    
    public void info(String message) {
        log("INFO", message);
    }
    
    public void error(String message) {
        log("ERROR", message);
    }
}

 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
32
33
34
35
36
37
38

// Spring의 관리하는 Singleton
@Component
@Scope("singleton")  // 기본값이므로 생략 가능
public class ConfigurationService {
    private final Properties properties;
    
    public ConfigurationService() {
        properties = new Properties();
        loadConfiguration();
    }
    
    public String getProperty(String key) {
        return properties.getProperty(key);
    }
    
    private void loadConfiguration() {
        // 설정 로드
    }
}

// 사용하는 쪽
@Service
public class OrderService {
    private final ConfigurationService configService;
    private final Logger logger;
    
    // 의존성이 명시적으로 주입됨
    public OrderService(ConfigurationService configService, Logger logger) {
        this.configService = configService;
        this.logger = logger;
    }
    
    public void processOrder(Order order) {
        String dbUrl = configService.getProperty("db.url");
        logger.info("Processing order: " + order.getId());
        // ...
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 인스턴스화를 방지하는 유틸리티 클래스
public class DateUtils {
    private DateUtils() {} // 인스턴스화 방지
    
    public static String formatDate(LocalDate date) {
        return date.format(DateTimeFormatter.ISO_LOCAL_DATE);
    }
    
    public static LocalDate parseDate(String dateString) {
        return LocalDate.parse(dateString, DateTimeFormatter.ISO_LOCAL_DATE);
    }
    
    public static boolean isWeekend(LocalDate date) {
        DayOfWeek dayOfWeek = date.getDayOfWeek();
        return dayOfWeek == DayOfWeek.SATURDAY || dayOfWeek == DayOfWeek.SUNDAY;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// JavaScript에서의 모듈 패턴
const configModule = (() => {
    let config = {};
    
    return {
        setConfig: (newConfig) => {
            config = { ...config, ...newConfig };
        },
        getConfig: () => ({ ...config }),
        getProperty: (key) => config[key]
    };
})();

// 사용법
configModule.setConfig({ dbUrl: 'localhost:5432' });
const dbUrl = configModule.getProperty('dbUrl');

 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
32
33
34
35
36
37
38
39

// 상황별 최적 구현 선택
public class SingletonChoiceGuide {
    
    // 1. 성능이 중요하고 즉시 초기화해도 되는 경우
    public class EagerCase {
        private static final EagerCase INSTANCE = new EagerCase();
        public static EagerCase getInstance() { return INSTANCE; }
    }
    
    // 2. 메모리 효율이 중요하고 복잡한 초기화가 없는 경우
    public class BillPughCase {
        private static class Helper {
            private static final BillPughCase INSTANCE = new BillPughCase();
        }
        public static BillPughCase getInstance() { return Helper.INSTANCE; }
    }
    
    // 3. 직렬화가 중요한 경우
    public enum EnumCase {
        INSTANCE;
        public void doSomething() { /* ... */ }
    }
    
    // 4. 대부분의 일반적인 경우
    public class GeneralCase {
        private static volatile GeneralCase instance;
        
        public static GeneralCase getInstance() {
            if (instance == null) {
                synchronized (GeneralCase.class) {
                    if (instance == null) {
                        instance = new GeneralCase();
                    }
                }
            }
            return instance;
        }
    }
}

 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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

// 기존 Singleton 코드
public class LegacySingleton {
    private static LegacySingleton instance;
    
    public static LegacySingleton getInstance() {
        if (instance == null) {
            instance = new LegacySingleton();
        }
        return instance;
    }
    
    public void doSomething() {
        // 비즈니스 로직
    }
}

// 1단계: 인터페이스 추출
public interface BusinessService {
    void doSomething();
}

public class LegacySingleton implements BusinessService {
    private static LegacySingleton instance;
    
    public static LegacySingleton getInstance() {
        if (instance == null) {
            instance = new LegacySingleton();
        }
        return instance;
    }
    
    @Override
    public void doSomething() {
        // 비즈니스 로직
    }
}

// 2단계: 일반 클래스로 변환
public class RefactoredBusinessService implements BusinessService {
    @Override
    public void doSomething() {
        // 동일한 비즈니스 로직
    }
}

// 3단계: DI로 관리
@Component
public class FinalBusinessService implements BusinessService {
    @Override
    public void doSomething() {
        // 동일한 비즈니스 로직
    }
}