본문 바로가기
Develop/Spring (이론)

싱글톤(Singleton) 딥다이브 ( Spring 內 싱글톤 컨테이너 비교)

by 보보트레인 2023. 8. 12.

사건의 발단 : 만약 싱글톤 방식의 설계가 없다면? 

 

매번 요청시 마다 새로운 memberService가 생성될 것. - 자원의 낭비

우리가 만들었던 스프링 없는 순수한 DI 컨테이너인 AppConfig는 요청을 할 때 마다 객체를 새로 생성한다.
고객 트래픽이 초당 100이 나오면 초당 100개 객체가 생성되고 소멸된다! 메모리 낭비가 심하다.

 

<증명 예제>

package hello.core.singleton;

import hello.core.AppConfig;
import hello.core.member.MemberService;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

public class SingletonTest {

    @Test
    @DisplayName("스프링 없는 순수한 DI 컨테이너")
    void pureContainer() {
        AppConfig appConfig = new AppConfig();
        //1. 조회 : 호출할 때 마다 객체를 생성
        MemberService memberService1 = appConfig.memberService();

        //2. 조회 : 호출할 때 마다 객체를 생성
        MemberService memberService2 = appConfig.memberService();

        //참조 값이 다른 것을 확인
        System.out.println("memberService1 = " + memberService1);
        System.out.println("memberService2 = " + memberService2);
    }
}

<실행 결과>

매번 다른 참조값이 생성되는 것을 확인할 수 있다.

 

<결론>

해결방안은 해당 객체가 딱 1개만 생성되고, 공유하도록 설계하면 된다.  → 싱글톤 패턴 탄생

싱글톤 패턴

- 클래스의 인스턴스가 딱 1개만 생성되는 것을 보장하는 디자인 패턴이다.
- 객체 인스턴스를 2개 이상 생성하지 못하도록 막아야 한다.
※ private 생성자를 사용해서 외부에서 임의로 new 키워드를 사용하지 못하도록 막아야 한다.

※ static을 사용하여 정적 맴버로 선언함으로써 공용으로 사용한다.

 

<예제>

 

싱글톤 패턴을 사용하기 위해서는 새로운 클래스를 만들고(SingletonService.java) 다음의 코드를 작성하여 항상 같은 인스턴스를 반환하도록 설정한다 (private와 static이용)

package hello.core.singleton;

public class SingletonService {

    //private static으로 해당 패키지에서 딱 하나만 존재하도록 제한 -> static으로 하면 클래스 레벨 단위로 올라가기 때문에...
    private static final SingletonService instance = new SingletonService();

    //instance를 미리 하나 생성해서 올려두고 오직 getInstance() 메서드를 통해서마 조회할 수 있다.
    // 이 인스턴스는 항상 같은 인스턴스를 반환 -> 싱글톤
    public static SingletonService getInstance() {
        return instance;
    }

    //private로 생성자를 막아서 외부(다른 패키지)에서 new키워드로 생성되는 것을 막는다.
    private SingletonService() {

    }

    public void logic() {
        System.out.println("싱글톤 객체 로직 호출");
    }

    public static void main(String[] args) {
        SingletonService singletonService1 = new SingletonService();
        SingletonService singletonService2 = new SingletonService();

    }
}

 

이후 테스트 코드를 다시 작성해보자!

package hello.core.singleton;

import hello.core.AppConfig;
import hello.core.member.MemberService;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

public class SingletonTest {

    @Test
    @DisplayName("싱글톤 패턴을 적용한 객체 사용")
    void singletonServiceTest() {
        // new SingletonService(); 하면 오류남 -> private로 막았기 때문
        SingletonService SingletonService1 = SingletonService.getInstance();
        SingletonService SingletonService2 = SingletonService.getInstance();

        //참조 값이 같은 것을 확인
        System.out.println("SingletonService1 = " + SingletonService1);
        System.out.println("SingletonService2 = " + SingletonService2);
    }
}

<실행결과>

같은 참조값이 나오는 것을 알 수 있다.

 

<결론>

싱글톤 패턴을 적용하면 고객의 요청이 올 때 마다 객체를 생성하는 것이 아니라, 이미 만들어진 객체를 공유해서 효율
적으로 사용할 수 있다.

그럼에도 불구하고 싱글톤에도 단점이 있다!

- 싱글톤 패턴을 구현하는 코드 자체가 많이 들어간다.
- 의존관계상 클라이언트가 구체 클래스에 의존한다. DIP를 위반한다. (킅라이언트가 싱글톤 객체를 의존)
- 클라이언트가 구체 클래스에 의존해서 OCP 원칙을 위반할 가능성이 높다. (개방 폐쇄 원칙)
- 테스트하기 어렵다.
- 내부 속성을 변경하거나 초기화 하기 어렵다.
- private 생성자로 자식 클래스를 만들기 어렵다.
- 결론적으로 유연성이 떨어진다.
- 안티패턴으로 불리기도 한다.

근데 우리는 걱정할 것이 없다!

스프링을 사용하면 container가 알아서 객체를 싱글톤 방식으로 관리해주고 문제점도 해결해 주기 때문이다!

→ 싱글톤 컨테이너라 부른다. (스프링 빈이 바로 싱글톤으로 관리되는 빈이다.)

 

<spring에서의 싱글톤 컨테이너 장점>

  • 싱글톤 패턴을 위한 지저분한 코드가 들어가지 않아도 된다.
  • DIP, OCP, 테스트, private 생성자로 부터 자유롭게 싱글톤을 사용할 수 있다.

 

<예제>

  @Test
    @DisplayName("스프링 컨테이너와 싱글톤")
    void springContainer() {
        //스프링컨테이너 사용하여 싱글톤 컨테이너 거쳐 생성
        ApplicationContext ac  = new AnnotationConfigApplicationContext(AppConfig.class);
        //1. 조회 : 싱글톤 방식으로
        MemberService memberService1 = ac.getBean("memberService", MemberService.class);
        MemberService memberService2 = ac.getBean("memberService", MemberService.class);

        //참조 값이 다른 것을 확인
        System.out.println("memberService1 = " + memberService1);
        System.out.println("memberService2 = " + memberService2);

        //memberService1 은  memberService2와 같아야 한다.
        assertThat(memberService1).isSameAs(memberService2);


    }

 

<결과>

참조값이 동일하게 싱글톤 방식으로 잘 생성됨을 확인할 수 있다.

 

<결론>

 

 

참고: 스프링의 기본 빈 등록 방식은 싱글톤이지만, 싱글톤 방식만 지원하는 것은 아니다. 요청할 때 마다 새로운
객체를 생성해서 반환하는 기능도 제공한다. 자세한 내용은 뒤에 빈 스코프에서 설명하겠다.

 

 

싱글톤 방식의 주의할 점

 

여러 클라이언트가 하나의 같은 객체 인스턴스를 공유하기 때문에,

싱글톤 객체는 상태를 유지(stateful)하게 설계하면 안된다.


▶ 무상태(stateless)로 설계해야 한다!

· 특정 클라이언트에 의존적인 필드가 있으면 안된다.
· 특정 클라이언트가 값을 변경할 수 있는 필드가 있으면 안된다!
· 가급적 읽기만 가능해야 한다.
· 필드 대신에 자바에서 공유되지 않는, 지역변수, 파라미터, ThreadLocal 등을 사용해야 한다.

 

<예제>

package hello.core.singleton;

public class StatefulService {

    private int price; //상태를 유지하는 필드

    public void order(String name, int price) {
        System.out.println("name = " + name + " price = " + price);
        this.price = price; //여기가 문제!

    }
    public int getPrice() {
        return price;
    }
}

1. 먼저 price를 조회해주는  order서비스 클래스를 하나 만든다 (StatefulSerivce)

 

package hello.core.singleton;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;

import javax.swing.plaf.nimbus.State;
import java.sql.SQLOutput;

public class StatefulServiceTest {

    @Test
    void statefulServiceSingleton() {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(TestConfig.class);
        StatefulService statefulService1 = ac.getBean(StatefulService.class);
        StatefulService statefulService2 = ac.getBean(StatefulService.class);

        //ThreadA
        statefulService1.order("userA", 10000);
        //ThreadB
        statefulService1.order("userB", 20000);

        //ThreadA : 사용자A 주문 금액 조회
        int price = statefulService1.getPrice();
        //엥 왜 20000이 나오지?  -> 싱글톤의 문제점 발생 (자원의 공유로 인한 문제)
        System.out.println("price = " + price);

        Assertions.assertThat(statefulService1.getPrice()).isEqualTo(20000);
    }

    static class TestConfig{

        @Bean
        public StatefulService statefulService() {
            return new StatefulService();
        }

    }
}

2. 방금 만들어둔  order서비스를 spring내 싱글톤 컨테이너를 통해 받아올 수 있도록 TestConfig라는 static class를 만든다.

 

3. 이를 이용하여 2개의 주문을 동시에 조회했을 때 (실제 스레드를 사용하지는 않지만 두개의 스레드를 간단하게 구현해보았다), StatefulService` 의 `price` 필드는 공유되는 필드임을 이해하자.

 

<테스트 결과>

 

 

4. 사용자 a의 주문금액은 10000인데 20000이 조회된다.

공유되는 필드(by singleton컨테이너) 때문에  생긴 문제이다.

 

 

<해결방법>

package hello.core.singleton;

public class StatefulService {

    // private int price; //상태를 유지하는 필드 (공유필드)

    //공유필드를 지우고 공유되지 않는 지역변수로 활용하자
    public int order(String name, int price) {
        System.out.println("name = " + name + " price = " + price);
        //this.price = price; //여기가 문제!
        return price;
    }
    public int getPrice() {
     //   return price;
    }
}

일단 공유필드(price)를 공유되지 않는 지역변수로 전환 (stateful 하게)

package hello.core.singleton;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;

import javax.swing.plaf.nimbus.State;
import java.sql.SQLOutput;

public class StatefulServiceTest {

    @Test
    void statefulServiceSingleton() {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(TestConfig.class);
        StatefulService statefulService1 = ac.getBean(StatefulService.class);
        StatefulService statefulService2 = ac.getBean(StatefulService.class);

        //ThreadA
        //statefulService1.order("userA", 10000);
        int userAPrince = statefulService1.order("userA", 10000);
        //ThreadB
        //statefulService1.order("userB", 20000);
        int userBPrince = statefulService2.order("userB", 20000);

        //ThreadA : 사용자A 주문 금액 조회
        //int price = statefulService1.getPrice();

        System.out.println("price = " + userAPrince);

      //  Assertions.assertThat(statefulService1.getPrice()).isEqualTo(20000);
    }

    static class TestConfig{

        @Bean
        public StatefulService statefulService() {
            return new StatefulService();
        }

    }
}

int 지역변수로 결과값을 받게

 

<결과>

a의 price가 10000으로 잘 출력됨을 확인할 수 있다.

반응형

'Develop > Spring (이론)' 카테고리의 다른 글

@ComponentScan & 의존성 주입(@Autowired) 딥다이브  (0) 2023.08.18
@Configuration과 싱글톤  (0) 2023.08.17
스프링 빈 설정 메타 정보 _ BeanDefinition  (0) 2023.08.11
스프링의 다양한 설정 형식 지원 - 자바 코드 , XM  (0) 2023.08.10
BeanFactory와 ApplicationContext  (0) 2023.08.10

관련글

티스토리툴바