[Java, 디자인 패턴] - 싱글턴 패턴(Singleton Pattern)

📎  글또 6기 포스팅

1. 미치도록 더웠던 7월의 회고

 

2. 사용자가 게시물을 작성할 때의 트랜잭션 처리

 

3. Spring AOP - (1) 프록시 패턴, 데코레이터 패턴

 

4. [MySQL] - 트랜잭션의 격리 수준(Isolation level)

 

5. Spring AOP - (2) AOP 개념 및 실습

 

6. 인텔리제이(IntelliJ) - 디버깅(Debugging) 하기

 

7. [Java, 디자인패턴] - 싱글턴 패턴(Singleton Pattern)

 

8. 월간 코드리뷰 Ver_0.1: 커리어 성장 CODE 세미나 정리

 

9. 포스트맨(API 테스트) 활용하기

 

10. 뜻깊은 2021년 회고

---

📎 디자인 패턴 - 싱글턴 패턴(Singleton Pattern)

포스팅에서 작성한 예제 코드는 깃허브에서 확인하실 수 있습니다 :)

 

안녕하세요, 이번 시간에 정리할 내용은 디자인 패턴에서의 싱글턴 패턴입니다. 그동안 디자인 패턴의 중요성에 대해서는 자주 들어왔었습니다. 하지만 디자인 패턴을 학습하더라도 실제 개발을 진행하며 디자인 패턴을 직접 적용해보는 일이 없었기에 다시 까먹게되는 악순환이 반복됐었는데요, 이번에 디자인 패턴에 대해 천천히 정리를 하여 앞으로 개발을 진행할 때 적절한 상황에서 적절한 패턴을 적용할 수 있도록 미리 학습하는 것을 목표로 하고자 합니다. 이러한 디자인 패턴을 실무에서 적용해 개발을 진행하려면 최소한 개념정도는 파악을 하고 있어야 하기 때문입니다.

 

 

 

🎯  디자인 패턴

---

먼저 싱글턴 패턴에 대해 살펴보기전, 디자인패턴에 대해 간략히 살펴보겠습니다.

나무위키에서 디자인 패턴은 객체 지향 프로그래밍 설계를 할 때 자주 발생하는 문제들을 피하기 위해 사용되는 패턴 이라고 정의하고 있습니다. 디자인 패턴에 적절한 격언으로 '바퀴를 다시 발명하지 마라(Don't reinvent the wheel)' 라는 말이 있습니다. 이 말은 이미 만들어져서 잘 되는 것을 처음부터 다시 만들 필요가 없다는 의미입니다. 즉, 불필요하게 처음부터 다시 시작할 필요가 없다는 것을 의미합니다.

 

패턴(Pattern)이란, '일정한 형태의 양식이나 유형'을 의미합니다. 정리해보자면, 어떤 비슷하거나 동일한 양식 또는 유형들이 반복되어 나타난다는 의미로도 해석할 수 있습니다. 여기서 중요한 점은 반복되어 나타난다는 의미입니다. 그동안 개발을 진행하면서 귀가 닳도록 들어왔던 말 중 하나가 '반복되는 코드를 작성하지 말라' 였습니다. 다양한 소프트웨어를 개발할 때 서로간에 공통되는 설계 문제가 존재하며, 이를 처리하는 해결책 사이에도 공통점이 존재합니다. 

 

디자인 패턴의 구조는 콘텍스트(context), 문제(problem), 해결(solution) 이라는 3개의 필수적인 요소로 구성이 됩니다.

• 콘텍스트란, 문제가 발생하는 여러 상황을 기술합니다. 즉, 패턴이 적용될 수 있는 상황을 나타냅니다. 경우에 따라서는 이러한 패턴이 유용하지 못한 상황도 존재합니다.
• 문제란, 패턴이 적용되어 해결될 필요가 있는 여러 디자인 이슈들을 기술합니다. 이때, 여러 제약 사항과 영향력도 문제해결을 위해 고려해야 합니다.
• 해결이란, 문제를 해결하도록 설계를 구성하는 요소들과 그 요소들 사이의 관계, 책임, 협력 관계를 기술합니다.

디자인 패턴의 구성 요소

 

 

 

📝  싱글턴 패턴

---

앞서 디자인 패턴에 대해 간략히 설명을 했었는데요, 이제 싱글턴 패턴에 대해 알아보겠습니다.

싱글턴 패턴이란, 인스턴스가 오직 하나만 생성되는 것을 보장하고 어디서든 동일한 인스턴스에 접근할 수 있도록 하는 디자인 패턴입니다.

싱글턴 패턴은 생성 패턴의 한 종류로, 생성 패턴은 객체 생성에 관련된 패턴으로 객체의 생성과 조합을 캡슐화해 특정 객체가 생성되거나 변경되어도 프로그램 구조에 영향을 크게 받지 않는 유연성을 제공합니다.

 

인스턴스가 오직 하나만 생성되어야 하는 상황을 가정하기 위해, 현실세계에서 프린터를 사용하는 예시를 들어보겠습니다.

A라는 회사는 현재 코로나로 인해 사정이 넉넉치 않기 때문에 예산을 최대한 줄여야 합니다. 이를 위해 사내에서 사용되는 프린터는 한 대를 제외하고 모두 처분을 해버렸습니다. 따라서 모든 직원들은 동일한 프린터 한 대만 공유해서 사용을 해야 합니다.

이를 간단하게 코드롤 나타내보겠습니다.

public class Printer {

    private static Printer printer;

    // 인스턴스화를 막는다.
    private Printer() { }

    // 싱글턴 패턴(단일 인스턴스)
    public static Printer getInstance() {
        if (printer == null) {
            printer = new Printer();
        }
        return printer;
    }

    public void print(final String message) {
        System.out.println(message);
    }
}


public class User {
    private final String name;

    public User(String name) {
        this.name = name;
    }

    public void print() {
        Printer printer = Printer.getInstance();
        printer.print(this.name + " print using " + printer);
    }
}


import org.junit.jupiter.api.Test;

class PrinterTest {

    @Test
    void 단일_스레드_프린터() {
        final int userNumber = 5;
        User[] users = new User[userNumber];

        for (int i = 0; i < userNumber; i++) {
            users[i] = new User((i + 1) + "-user");
            users[i].print();
        }
    }
}

현재 Printer 클래스의 객체는 private을 통해 외부에서 생성이 불가능하고 내부의 getInstance() 메소드를 통해서만 가능합니다.

또한 위 결과를 보면 5개의 Printer 인스턴스가 전부 동일하게 출력이 되는것을 확인할 수 있습니다.

※ 보통, 싱글턴 패턴을 나타낼때 메소드는 getInstance()라는 이름을 사용하곤 합니다.

 

따라서 위와 같이 코드를 작성하면 되는 것 같지만, 실제로는 문제점이 많이 존재합니다. 

아래에서 좀 더 살펴보겠습니다.

 

 

 

📌  문제점

---

위 프린터는 모든 인스턴스가 동일하기 때문에 싱글턴 패턴을 만족하는 것 처럼 보이지만, 실제로는 그렇지 않습니다.

멀티 스레드의 환경에서는 문제가 발생할 수 있는데요, 다음과 같은 시나리오가 존재할 수 있습니다.

• Printer 인스턴스가 생성되지 않았을 때 스레드 A가 getInstance() 메소드를 호출해 인스턴스가 생성되었는지 확인합니다.
• 위에서 스레드 A가 생성자를 호출해 인스턴스를 만들기 전, 스레드 B가 getInstance() 메소드를 호출해 if문을 실행한다면, 현재 Printer 인스턴스는 null이므로 인스턴스가 생성이 됩니다.
• 마찬가지로 스레드 A도 인스턴스를 생성하기 때문에 다른 인스턴스가 생성이 됩니다.

위 시나리오는 경합 조건(race condition)을 발생키는데, 경합 조건이란 메모리와 같은 동일한 자원을 2개 이상의 스레드가 이용하려고 경합하는 현상을 의미합니다.

 

멀티 스레드 환경에서의 코드를 살펴보겠습니다.

public class Printer {
   
    ...

    public static Printer getInstance() {
        if (printer == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException ignored) { }
            printer = new Printer();
        }
        return printer;
    }   
    
    
public class UserThread extends Thread {

    public UserThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        Printer printer = Printer.getInstance();
        printer.print(Thread.currentThread().getName() + " print using " + printer);
    }
}


    @Test
    void 다중_스레드_프린터() {
        UserThread[] userThreads = new UserThread[NUMBER];

        for (int i = 0; i < NUMBER; i++) {
            userThreads[i] = new UserThread((i + 1) + "-thread");
            userThreads[i].start();
        }
    }

Printer 클래스의 getInstance() 메소드에서 스레드 실행을 고의적으로 1ms동안 정지하도록 설정하였습니다.

그 후 Thread를 상속받는 UserThread 클래스를 생성하고, 테스트를 해보면 다음과 같습니다.

위 멀티 스레드의 결과를 살펴보면 모두 다른 인스턴스가 생성이 되는걸 확인할 수 있습니다.

 

 

 

🔑  해결방법

---

객체의 이른 초기화(eager initialization) 사용하기

객체를 lazy하게 생성하는 대신 미리 생성하는(이른 초기화) 방법이 존재합니다.

public class Printer {

    private static final Printer INSTANCE = new Printer();

    private Printer() { }

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

위 결과를 살펴보면 멀티 스레드 환경에서 모두 동일한 인스턴스가 생성이 되는것을 확인할 수 있습니다.

하지만 위 방법 또한 인스턴스를 생성하는 과정이 오래걸리고 메모리를 많이 사용하는데 반해 객체를 사용하지 않는다면 이또한 문제점이 발생할 수 있습니다.

 

 

synchronized 키워드 사용하기

public static synchronized Printer getInstance() {
  ...

위와 같이 사용하고자 하는 메소드에 synchronized 키워드를 사용하면 해결할 수 있습니다.

※ synchronized 키워드 외에도 변수에 volatile 키워드나 Atomic 클래스를 이용할수도 있습니다.

 

결과를 확인해보면 모두 동일한 인스턴스가 생성이 되는걸 확인할 수 있습니다.

※ synchronized 키워드에 대해서는 아래 포스팅에 자세히 설명이 되어있습니다.

• https://www.baeldung.com/java-synchronized
• https://tourspace.tistory.com/54

 

하지만 위와 같이 메소드 블록에 synchronized를 통해 동기화를 하면 극단적인 경우에서는 성능이 100배 이상 저하될 수 있다고 합니다.

출처: https://en.wikipedia.org/wiki/Double-checked_locking

 

 

double check locking

위와 같은 문제점은 double check locking이라는 방법을 통해 해결할 수 있습니다.

double check locking이란, 이름을 통해 파악을해보면 locking을 더블 체크하는 개념입니다.

public class Printer {

    private static Printer printer;

    private Printer() { }

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

메소드 블록에서 synchronized를 통한 동기화는 해당 메소드를 호출할 때마다 동기화를 하는 반면, 위 코드는 메소드 내부에서 Printer 인스턴스가 null일 때만 동기화를 설정하게 됩니다. 

따라서 메소드를 호출할 때마다 동기화를 하는 코드보단 성능면에서 이점이 있습니다.

 

하지만 위 코드도 문제점이 존재한다고 하는데요, 위키문서에서는 다음과 같이 이야기를 하고있습니다.

1. Thread A notices that the value is not initialized, so it obtains the lock and begins to initialize the value.
2. Due to the semantics of some programming languages, the code generated by the compiler is allowed to update the shared variable to point to a partially constructed object before A has finished performing the initialization. For example, in Java if a call to a constructor has been inlined then the shared variable may immediately be updated once the storage has been allocated but before the inlined constructor initializes the object.
3. Thread B notices that the shared variable has been initialized (or so it appears), and returns its value. Because thread B believes the value is already initialized, it does not acquire the lock. If B uses the object before all of the initialization done by A is seen by B (either because A has not finished initializing it or because some of the initialized values in the object have not yet percolated to the memory B uses (cache coherence)), the program will likely crash.

위에서 언급하고 있는 문제점에 대해 저의 현재 지식으로는 이해하기 힘든 부분이 많지만, 제가 이해한 바로는 멀티 스레드 환경에서 스레드 A와 스레드 B가 인스턴스의 생성이 되지 않았으나 생성이 되었다고 판단하는 인스턴스 생성 및 초기화 과정에서의 충돌이 발생할 수 있다고 말하는 것 같습니다.

(잘못된 내용이 있다면 말씀해주시면 감사하겠습니다 (__) 😂)

 

따라서 위 코드에서 printer 변수에 volatile을 선언해주면 해결이 됩니다.

private static volatile Printer printer;

...

volatile 키워드는 자바 변수를 '메인 메모리에 저장 해야할'표식으로 사용합니다. 이러한 volatile은 변수의 가시성(Visibility)을 보장하는데요, volatile 키워드에 대해 자세한 내용은 아래 링크를 참고해주세요.

• java volatile 키워드

 

하지만 위와 같은 코드도 Java 1.4까지는 문제가 발생할 수 있습니다.(Java 17이 나온 마당에 java 1.4가 있을까 싶긴 합니다만..)

Java 1.4까지 volatile 키워드는 이전에 읽히거나 쓰인 값이 컴파일러에 의해 재정렬이 될 수 있고, 이로 인해 double check locking에서 문제가 발생할 수 있다고 합니다. 이는 Java 1.5부터는 변경이 되었기때문에, Java 1.5부터는 신경쓰지 않아도 됩니다.

• https://stackoverflow.com/questions/10336006/using-volatile-keyword-in-java4-and-java5

 

 

static class를 통한 지연 초기화

위에서 살펴봤던 해결책들은 꽤나 복잡한 방법들입니다. Java 버전을 확인해야하며, volatile 키워드와 synchronized 키워드에 대해서도 습득하고 있어야 코드를 이해하고 사용할 수 있습니다.

 

그럼 좀 더 간편한 방법은 없을까요? 🤔 아래 코드를 살펴보겠습니다.

public class Printer {

    private Printer() { }

    private static class PrinterHolder {
        public static final Printer printer = new Printer();
    }

    public static Printer getInstance() {
        return PrinterHolder.printer;
    }
}

 

위 코드는 내부 클래스인 PrinterHolder가 호출이 될 때까지 로드가 되지 않는다는 사실에 의존합니다.

따라서 멀티 스레드 환경에서도 안전하고, getInstance() 메소드를 호출할 때 PrinterHolder 클래스를 호출하기 때문에 지연 초기화도 가능하게 됩니다. 또한 이전에 살펴봤던 double check locking와 같이 코드가 복잡하지 습니다.

 

실제 위 코드를 기반으로 테스트를 해보면 위와같이 모두 동일한 인스턴스가 생성이 됩니다.

 

 

멀티 스레드에서 자원을 공유하는 static class

멀티 스레드 환경에서 자원을 공유하면 동기화가 되는지 테스트해보겠습니다.

public class StaticPrinter {

    private static int counter = 0;

    public synchronized static void print(final String str) {
        counter++;
        System.out.println(str + " " + counter);
    }
}


public class StaticUserThread extends Thread {

    public StaticUserThread(String name) {
        super(name);
    }

    public void run() {
        StaticPrinter.print(Thread.currentThread().getName() + " print using ");
    }
}


class StaticPrinterTest {

    private static final int NUMBER = 5;

    @Test
    void 자원을_공유하는_멀티_스레드() {
        StaticUserThread[] user = new StaticUserThread[NUMBER];

        for (int i = 0; i < NUMBER; i++) {
            user[i] = new StaticUserThread((i + 1) + "-thread");
            user[i].start();
        }
    }
}

위 코드의 결과를 보면 counter 변수가 1씩 증가하는 것을 확인할 수 있습니다.

 

 

그럼 항상 static class를 사용하면 될까?

여러 자료들을 찾아보니 항상 그렇지는 않다고 합니다.

정적 클래스를 이용하는 방법과 싱글턴 패턴을 이용하는 방법중 가장 차이가 나는 점은 객체를 전혀 생성하지 않고 정적 메서드를 사용한다는 점인데요(코드가 궁금하시면 java.lang.Math 클래스를 참고해보시면 좋을 것 같습니다.) 위 결과에서 확인할 수 있듯이 문제 없이 counter 변수가 스레드 5개에서 안전하게 공유되어 사용될 수 있음을 알 수 있습니다. 더욱이 정적 메서드를 사용하므로 일반적으로 실행할 때 바인딩되는(컴파일 타임 바인딩) 인스턴스 메서드를 사용하는 것보다 성능면에서도 우수하다고 할 수 있습니다.

 

싱글턴 패턴의 경우 static class와는 달리 객체 내부에 공유하는 자원이 있을때 유용한데, 예를들어 데이터베이스나 in-memory 캐시 등과 같은 상태들이 있습니다. 즉, 프로그램의 여러 곳에서 위와 같은 공유 자원들을 사용하기를 원하고, 단일 지점(single point)를 통하여 이러한 자원들에 대해 접근하고자 할 때 유용하다고 합니다.

 

위의 내용들은 제가 경험해보지는 못한 아래 링크들을 참고하여 작성하였습니다. 틀린 내용이 있다면 피드백 부탁드립니다.

• When to use a Singleton and when to use a static class [duplicate]
• Difference between Singleton Pattern vs Static Class in Java? Example

 

 

 

✏️  정리

---

디자인 패턴 및 싱글턴 패턴에 대해 알아보았습니다. 그동안 싱글톤 패턴은 단순히 '인스턴스가 오직 하나만 생성된다.' 라는 개념만 알고 지내왔으며 인스턴스를 외부에서 생성할 수 없도록 생성자를 private로 막고 정적 메소드(getInstance)를 통해 인스턴스를 생성할 수 있다. 라는 정도로만 알고있었습니다. 이번 정리를 통해 싱글턴 패턴에 대해 좀 더 깊게 공부하고자 여러 자료들과 영상들을 참고해보았습니다. 

포스팅에서 설명드린 것처럼 싱글턴 패턴을 구현하는 방식에도 여러가지가 존재하며, 이와 관련해서 synchronized, volatile와 같은 키워드나 double check locking 등등의 용어에 대해서도 학습할 수 있는 시간이었습니다.

 

 

 

 

📝  References

• https://namu.wiki/w/%EB%94%94%EC%9E%90%EC%9D%B8%20%ED%8C%A8%ED%84%B4
• JAVA 객체 지향 디자인 패턴
• https://www.youtube.com/watch?v=bHRETd1rFfc
• https://en.wikipedia.org/wiki/Double-checked_locking
• https://stackoverflow.com/questions/10336006/using-volatile-keyword-in-java4-and-java5
• https://softwareengineering.stackexchange.com/questions/235527/when-to-use-a-singleton-and-when-to-use-a-static-class
• https://javarevisited.blogspot.com/2013/03/difference-between-singleton-pattern-vs-static-class-java.html#axzz7A17KIg6U%EF%BB%BF
• https://javarevisited.blogspot.com/2012/03/what-is-static-and-dynamic-binding-in.html#axzz7AAlNMjhN