[Spring] 동시성 문제 해결방법 (1) - synchronized, Lock 사용

 

 

 

 

 

🤔 서론

다중 사용자를 위한 웹 애플리케이션을 만들다 보면 한 번쯤은 동시성 문제에 접하게 됩니다.

동시성 문제는 하나의 자원에 대해서 여러 쓰레드가 동시에 접근하여 수정하는 경우에 발생하는 문제입니다.

 

동시성 문제가 발생하는 간단한 예시로는 특정 게시물의 조회 수가 올바르게 증가되지 않는 문제가 있을 수 있습니다.

특정 게시물에 100명의 사용자가 동시에 접근하는 경우 조회수는 100이 되어야 옳겠지만, 대부분의 경우 조회수는 100보다 작은 값으로 설정될 것입니다.

조회수 같은 경우에는 대체로 데이터의 정합성이 중요하지 않기 때문에 이러한 부분이 문제가 되지 않을 수 있지만, 상품의 재고 수량과 같은 경우에 이러한 동시성 문제가 발생한다면 치명적일 수 있습니다.

 

이러한 동시성 문제를 막기 위해서는 다양한 방법을 사용할 수 있는데요, 이번 글 부터 차례대로 여러가지 방법들에 대해 알아보도록 하겠습니다.

 

 

 

 

 

 

 

 

 

🤔 프로젝트 세팅

간단하게는 h2를 사용해서 별도의 설정 없이 진행할 수 있으나, 다음 글에서 진행되는 내용들까지 고려하여 docker 위에 MySQL을 띄워서 진행하도록 하겠습니다.

 

 

 

🐳 docker에 MySQL 설치

docker를 설치하고, 다음 명령어를 통해 Mysql을 실행해 주시면 됩니다.

docker pull mysql

docker run -d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=1234 --name mysql mysql

 

 

docker ps를 입력했을 때, 다음과 같이 보인다면 성공입니다.

 

 

 

 

 

 

 

🐳 MySQL 내부 접속 & 데이터베이스 생성

이후 다음 명령어들을 통해 docker 내부의 mysql에 접속합니다.

docker exec -it mysql bash

mysql -u root -p1234

 

 

 

이후 데이터베이스를 만들어주도록 하겠습니다.

create database stock;

use stock;

 

 

 

 

 

 

 

🐳 프로젝트 생성

start.spring.io

 

버전은 기본값 그대로 사용해 주시면 됩니다.

의존성은 위 사진과 같이, Spring Data JPA, Spring Web, MySQL Driver, Lombok(선택)을 선택 후 생성해주시면 됩니다.

 

 

이후 application.yml 파일을 다음과 같이 작성합니다.

spring:
  jpa:
    hibernate:
      ddl-auto: create
    show-sql: true
    properties:
      hibernate:
        format_sql: true
        use_sql_comments: true
        highlight_sql: true
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/stock
    username: root
    password: 1234

logging:
  level:
    org:
      hibernate:
        SQL: DEBUG
        type:
          descriptor:
            sql:
              BasicBinder: TRACE

 

 

 

 

 

 

 

🐳 로직 작성

동시성 문제가 발생하는 예시로는 재고 시스템을 가정하도록 하겠습니다.

하나의 창고에 특정 상품에 대한 재고가 100개인 경우, 동시에 100개의 재고 감소 요청이 들어왔을 때 최종적으로 재고가 0개가 되도록 하는 것이 목표입니다.

 

이제부터 클래스들을 작성할 것인데, 최종 구조는 다음과 같습니다.

 

@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
public class Stock {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private Long productId;

    private int quantity;

    public Stock(Long productId, int quantity) {
        this.productId = productId;
        this.quantity = quantity;
    }

    public void decrease() {
        if (this.quantity == 0) {
            throw new RuntimeException("재고는 0개 미만이 될 수 없습니다.");
        }
        this.quantity --;
    }
}

 

 

import org.springframework.data.jpa.repository.JpaRepository;

public interface StockRepository extends JpaRepository<Stock, Long> {

    default Stock getById(Long id) {
        return findById(id).orElseThrow(NoSuchElementException::new);
    }
}

 

 

@RequiredArgsConstructor
@Service
public class StockService {

    private final StockRepository stockRepository;

    @Transactional
    public void decrease(Long id) {
        Stock stock = stockRepository.getById(id);
        stock.decrease();
        stockRepository.saveAndFlush(stock);
    }
}

 

 

 

이제 테스트코드를 작성합니다.

@SpringBootTest
class StockServiceTest {

    @Autowired
    private StockService stockService;

    @Autowired
    private StockRepository stockRepository;
    
    private Long stockId;

    @BeforeEach
    void setUp() {
        stockId = stockRepository.saveAndFlush(new Stock(1L, 100))
                .getId();
    }

    @AfterEach
    void tearDown() {
        stockRepository.deleteAll();
    }

    @Test
    void decreaseStock() {
        // given
        stockService.decrease(stockId);

        // when
        Stock stock = stockRepository.getById(stockId);

        // then
        assertThat(stock.getQuantity()).isEqualTo(99);
    }
}

 

기본적인 세팅이 완료되었습니다.

이제 지금의 코드가 어떤 동시성 문제를 유발시킬 수 있는지에 대해 알아보도록 하겠습니다.

 

 

 

 

 

 

 

 

 

🤔 현재 코드의 문제점

위 테스트 코드의 상황은 요청이 1개만 들어온 경우에 대한 테스트 코드로써, 요청이 1개인 경우에는 재고 감소가 올바르게 이루어지는 것을 확인할 수 있었습니다.

그러나 요청이 동시에 100개가 들어온다면 어떻게 동작하게 될까요?

이러한 상황을 테스트 코드를 통해서 살펴보도록 하겠습니다.

 

    @Test
    void decrease_with_100_request() throws InterruptedException {
        // given
        int threadCount = 100;
        ExecutorService executorService = Executors.newFixedThreadPool(32);
        CountDownLatch latch = new CountDownLatch(threadCount);

        // when
        for (int i = 0; i < threadCount; i++) {
            executorService.submit(() -> {
                try {
                    stockService.decrease(stockId);
                } catch (Exception e) {
                    latch.countDown();
                }
            });
        }
        latch.await();

        // then
        Stock stock = stockRepository.getById(stockId);
        assertThat(stock.getQuantity()).isEqualTo(0);
    }

 

 

 

위 코드의 결과는 다음과 같습니다.

Actual은 계속해서 달라질 수 있으며, 중요한 것은 남은 재고가 0이 아니라는 것입니다.

 

 

위 문제가 발생하는 이유는 바로 Race Condition 때문입니다.

💡 Race Condition이란 두 개 이상의 프로세스(혹은 스레드)들이 하나의 자원에 접근하여 변경하는 경우, 접근 순서에 따라 실행 결과가 달라지는 현상을 의미합니다.

 

 

문제 상황을 간략히 보기 위해 그림을 통해 알아보도록 하겠습니다.

 

저희가 기대하는 정상적인 동작은 다음과 같습니다.

 

 

 

그러나 실제로는 아래와 같이 동작함으로써 예상치 못한 동시성 문제가 발생하게 됩니다.

 

위 문제를 해결하기 위해서는 하나의 쓰레드의 작업이 완료된 이후에만 다른 쓰레드가 공유 자원에 접근할 수 있도록 해주어야 합니다.

 

 

 

 

 

 

 

 

 

 

 

🤔 해결 - synchronized 사용

자바에서 제공하는 synchronized 키워드를 통해, 간단하게 한 개의 쓰레드만 접근이 가능하도록 설정해줄 수 있습니다.

 

기존 코드를 다음과 같이 변경합니다.

@RequiredArgsConstructor
@Service
public class StockService {

    private final StockRepository stockRepository;

    @Transactional
    public synchronized void decrease(Long id) {
        Stock stock = stockRepository.getById(id);
        stock.decrease();
        stockRepository.saveAndFlush(stock);
    }
}

 

 

이제 다시 테스트를 실행하면 다음과 같이 실패하는 것을 확인할 수 있습니다.

 

 

이는 스프링의 @Transactional 어노테이션으로 인해 발생하는 문제로써, 문제가 발생하는 이유를 간략화하면 다음과 같습니다.

 

@Transactional이 붙은 메서드는 스프링에서 만들어주는 어떠한 객체로 감싸지게 되는데요, 이때 동작을 간단히 표현하면 다음과 같습니다.

 

 

이때 아래와 같이 stockService.decrease()가 호출된 후 트랜잭션이 끝나기 전에 다른 쓰레드에서 decrease() 메서드를 호출할 수 있습니다.

이로 인해 동시성 문제가 해결되지 않은 것입니다.

 

@Transactional 어노테이션을 제거함으로써 위 문제를 해결할 수 있습니다.

@RequiredArgsConstructor
@Service
public class StockService {

    private final StockRepository stockRepository;

    public synchronized void decrease(Long id) {
        Stock stock = stockRepository.getById(id);
        stock.decrease();
        stockRepository.saveAndFlush(stock);
    }
}

 

 

 

 

 

 

 

 

🤔 synchronized의 문제점

synchronized를 통해 간단하게 문제를 해결할 수 있으나, 이는 두 가지 문제점을 가집니다.

 

1. 트랜잭션이 보장되지 않는다

위 로직은 간단하기 때문에 @Transactional이 붙어있지 않아도 큰 문제가 발생하지 않지만, 하나의 트랜잭션으로 처리해야 하는 작업이 많아지는 경우 이들을 하나의 트랜잭션으로 처리할 수 없어지는 문제가 발생하게 됩니다.

 

 

2. 다중 웹 서버 환경에서는 적용할 수 없다.

synchronized 키워드는 하나의 프로세스 내에서만 보장이 됩니다.

서버가 한 대일 경우에는 괜찮겠지만 Scale Out을 통해 서버가 2대 이상으로 늘어나는 경우에는 여러 서버에서 데이터의 접근이 가능하게 되므로 여전히 동시성 문제가 발생하게 됩니다.

 

 

 

 

 

 

 

 

🤔 다중 웹 서버 환경에서의 동작 테스트하기

정말 다중 웹 서버 환경에서는 synchronized를 통해서 문제가 해결되지 않는지 테스트해보도록 하겠습니다.

 

다음 코드를 추가합니다.

@RequiredArgsConstructor
@RestController
public class StockController {

    private final StockService stockService;
    private final StockRepository stockRepository;

    @GetMapping("/stocks")
    public void createStock() {
        stockRepository.save(new Stock(1L, 100));
    }

    @GetMapping("/stocks/{id}/decrease")
    public void decreaseStock(
            @PathVariable Long id
    ) {
        stockService.decrease(id);
    }
}

 

이후 포트를 달리 하여 서버 2대를 실행시키도록 하겠습니다.

(인텔리에지에서 이를 위해서는 allow multiple instances 옵션이 켜져 있어야 하며, 다음 사이트를 참고하여 설정합니다.)

 

한 대의 서버는 바로 실행시킨 뒤, 두 번째 서버를 실행시킬 때는 application.yml을 다음과 같이 변경하고 실행시켜줍니다.

spring:
  jpa:
    hibernate:
      ddl-auto: validate  # 수정
    show-sql: true
    properties:
      hibernate:
        format_sql: true
        use_sql_comments: true
        highlight_sql: true
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/stock
    username: root
    password: 1234

logging:
  level:
    org:
      hibernate:
        SQL: DEBUG
        type:
          descriptor:
            sql:
              BasicBinder: TRACE

server:
  port: 8081 # 추가

 

서버를 실행하였다면 Postman등을 사용하여 http://localhost:8080/stocks로 get 요청을 한 번 보내줍니다.

 

이후 MySQL 내부에서 재대로 상품이 생성되었는지 확인합니다.

 

 

 

 

 

이제 다음 코드를 통해 먼저 한 대의 서버에만 동시에 100개의 요청을 보내보도록 하겠습니다.

class MultiServerStockServiceTest {

    @Test
    void decrease_with_100_request_to_multi_server() throws InterruptedException {
        // given
        int threadCount = 100;
        RestTemplate restTemplate = new RestTemplate();
        ExecutorService executorService = Executors.newFixedThreadPool(32);
        CountDownLatch latch = new CountDownLatch(threadCount);

        // when
        for (int i = 0; i < threadCount; i++) {
            executorService.submit(() -> {
                try {
                    int port = 8080;
                    ResponseEntity<Void> forEntity = restTemplate.getForEntity(
                            "http://localhost:" + port + "/stocks/1/decrease",
                            Void.class);
                } finally {
                    latch.countDown();
                }
            });
        }
        latch.await();
    }
}

 

최종적으로 stock의 수량을 확인하면 다음과 같습니다.

 

위를 통해 단일 서버에서는 synchronized를 통해 동시성 문제가 방지됨을 확인할 수 있었습니다.

 

 

 

 

이어서 2대의 서버에 대해 동일하게 100개의 요청을 보내도록 하겠습니다.

(이전 테스트와 마찬가지로, 두 서버를 모두 재실행 해준 뒤, http://localhost:8080/stocks로 get 요청을 보내줍니다.)

코드는 다음과 같습니다.

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.junit.jupiter.api.Test;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

class MultiServerStockServiceTest {

    @Test
    void decrease_with_100_request_to_multi_server() throws InterruptedException {
        // given
        int threadCount = 100;
        RestTemplate restTemplate = new RestTemplate();
        ExecutorService executorService = Executors.newFixedThreadPool(32);
        CountDownLatch latch = new CountDownLatch(threadCount);

        // when
        for (int i = 0; i < threadCount; i++) {
            final int ii = i;
            executorService.submit(() -> {
                try {
                    int port = (ii % 2 == 0) ? 8080 : 8081;
                    ResponseEntity<Void> forEntity = restTemplate.getForEntity(
                            "http://localhost:" + port + "/stocks/1/decrease",
                            Void.class);
                }  finally {
                    latch.countDown();
                }
            });
        }
        latch.await();
    }
}

 

결과를 확인하면 다음과 같습니다.

 

위를 통해 2개 이상의 다중 서버 환경에서는 synchronized 키워드를 통해 동시성 문제를 해결할 수 없음을 확인할 수 있었습니다.

 

 

 

 

 

 

 

 

 

🤔 해결 - Lock

synchronized 이외에도 java에서 제공해주는 Lock을 통해 문제를 해결할 수 있습니다.

StockService 코드를 다음과 같이 작성합니다.

@RequiredArgsConstructor
@Service
public class StockService {

    private final StockRepository stockRepository;

    @Transactional
    public void decrease(Long id) {
        Stock stock = stockRepository.getById(id);
        stock.decrease();
        stockRepository.saveAndFlush(stock);
    }
}

 

 

이후 Lock을 통해 동시성 제어를 담당하는 Facade들 만들어 주겠습니다.

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

@RequiredArgsConstructor
@Service
public class LockStockFacade {

    private ConcurrentHashMap<String, Lock> locks = new ConcurrentHashMap<>();

    private final StockService stockService;

    public void decrease(Long id) throws InterruptedException {
        Lock lock = locks.computeIfAbsent(String.valueOf(id), key -> new ReentrantLock());
        boolean acquiredLock = lock.tryLock(3, TimeUnit.SECONDS);
        if (!acquiredLock) {
            throw new RuntimeException("Lock 획득 실패");
        }
        try {
            stockService.decrease(id);
        } finally {
            lock.unlock();
        }
    }
}

 

 

 

위 코드를 실행해보기 위해 다음 테스트코드를 작성합니다.

@SpringBootTest
class LockStockFacadeTest {

    @Autowired
    private LockStockFacade lockStockFacade;
    
    @Autowired
    private StockRepository stockRepository;

    private Long stockId;

    @BeforeEach
    void setUp() {
        stockId = stockRepository.saveAndFlush(new Stock(1L, 100))
                .getId();
    }

    @AfterEach
    void tearDown() {
        stockRepository.deleteAll();
    }

    @Test
    void decrease_with_100_request_lock_facade() throws InterruptedException {
        // given
        int threadCount = 100;
        ExecutorService executorService = Executors.newFixedThreadPool(32);
        CountDownLatch latch = new CountDownLatch(threadCount);

        // when
        for (int i = 0; i < threadCount; i++) {
            executorService.submit(() -> {
                try {
                    lockStockFacade.decrease(stockId);
                } catch (Exception e) {
                    System.out.println(e);
                } finally {
                    latch.countDown();
                }
            });
        }
        latch.await();

        // then
        Stock stock = stockRepository.getById(stockId);
        assertThat(stock.getQuantity()).isEqualTo(0);
    }
}

 

 

성공하는 것을 알 수 있습니다.

그러나 Lock을 사용하는 방법 역시도 synchronized와 같이 다중 서버 환경에서는 제대로 작동하지 않습니다.

 

 

 

 

 

🐳 참고: 부트 3.2 이상 버전 - LockRegistry

스프링부트 3.2 버전 이상부터는 Spring Integration 의존성을 추가한 뒤, LockRegistry를 통해 다음과 같이 간편하게 사용할 수도 있습니다.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.support.locks.DefaultLockRegistry;
import org.springframework.integration.support.locks.LockRegistry;

@Configuration
public class LockConfig {

    @Bean
    public LockRegistry lockRegistry() {
        return new DefaultLockRegistry();
    }
}

@RequiredArgsConstructor
@Service
public class LockStockFacade {

    private final LockRegistry lockRegistry;
    private final StockService stockService;

    public void decrease(Long id) throws InterruptedException {
        lockRegistry.executeLocked(String.valueOf(id), () -> {
            stockService.decrease(id);
        });
    }
}

 

 

 

 

 

 

 

 

 

🤔 마무리

이번 글에서는 동시성 문제가 무엇인지와, synchronized, Lock를 통해 단일 웹 서버 환경에서 이를 어떻게 해결할 수 있는지에 대해 알아보았습니다.

그러나 synchronized는 여러 대의 서버에서 동일 자원에 접근하는 경우에는 사용할 수 없다는 문제점이 존재했습니다.

다음 글에서는 데이터베이스의 낙관적 락과 비관적 락을 통해 다중 서버 환경에서 동시성 문제를 해결하는 방법에 대해 알아보겠습니다.

 

 

 

 

 

 

 

 

 

📚 Reference

[재고시스템으로 알아보는 동시성이슈 해결방법]

https://www.youtube.com/watch?v=F-KDcb3FBuw

https://docs.spring.io/spring-integration/reference/distributed-locks.html