재고 데이터를 Redis에서 관리했을 때 분산락의 필요성

1. 현재 강의에서 재고 데이터를 MySQL에서 관리하고 있는데, 만약에 다중 서버 환경이라고 가정하고, 재고 데이터를 Redis에서 관리한다했을 때에도 분산락이 필요한건가요?

2. 제가 redisson을 이용해서 재고 감소 시키는 로직과 redisson을 이용하지 않고 재고 감소 시키는 로직을 구현했는데, 제가 예상한 바로는 redisson을 이용하지 않고 재고 감소 시킬 때에는 데이터 정합성이 맞지 않고, redisson을 이용해서 재고 감소시키는 로직에선느 데이터 정합성이 맞을 것이다라고 생각했는데, 결과는 둘다 동일하게 데이터 정합성이 맞더라구요. 왜 그런걸까요?

1번째 코드는 구현코드고, 2번째 코드는 테스트 코드입니다.

@Repository
public class InventoryRepository {

    private final RedisStringsRepository redisStringsRepository;

    private final RedissonClient redissonClient;

    private int waitTimeForAcquiringLock  = 1;

    private int leaseTimeForLock  = 1;

    @Autowired
    public InventoryCommandRepository(
        RedisStringsRepository redisStringsRepository,
        RedissonClient redissonClient
    ) {
        this.redisStringsRepository = redisStringsRepository;
        this.redissonClient = redissonClient;
    }

    public void set(String key, int amount) {
        redisStringsRepository.set(key, String.valueOf(amount));
    }

    public void delete(String key) {
        redisStringsRepository.delete(key);
    }

    // lock 없이 재고 로직 감소
    public void decreaseByAmountWithoutLock(String key, int amount) {
        redisStringsRepository.decreaseByAmount(key, Long.valueOf(amount));
    }

    // lock 하고 재고 로직 감소
    public void decreaseByAmount(String key, int amount) {

        RLock rlock = redissonClient.getLock(key+"lock");

        try {

            boolean available = rlock.tryLock(waitTimeForAcquiringLock, leaseTimeForLock, TimeUnit.SECONDS);

            if (!available) {
                System.out.println("lock 획득 실패 "); 
                return;
            }

            redisStringsRepository.decreaseByAmount(key, Long.valueOf(amount));

        } catch (InterruptedException e) {
            throw new RuntimeException(e);
            if (rlock != null && rlock.isLocked()) {
                rlock.unlock();
            }
        }
    }
}

@DisplayName("InventoryRepository")
@SpringBootTest
public class InventoryRepositoryTest {

    @Autowired
    private InventoryRepository inventoryRepository;

    @Autowired
    private RedisStringsRepository redisStringsRepository;

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    String key = "testKey";

    int initialAmount = 100;

    @BeforeEach
    public void setUp() {
        redisStringsRepository.set(key, String.valueOf(initialAmount));
    }

    @AfterEach
    void teardown() {
        redisStringsRepository.delete(key);
    }

    @Nested
    @DisplayName("decreaseByAmountWithoutLock")
    class Describe_decreaseByAmountWithoutLock {

        @Nested
        @DisplayName("with 1 thread")
        class Context_With_Single_Thread {

            @Test
            @DisplayName("decreases inventory by amount")
            void It_Decreases_Inventory_By_Amount() throws InterruptedException {
                int decreaseAmount = 1;

                inventoryRepository.decreaseByAmountWithoutLock(key, decreaseAmount);

                String value = redisStringsRepository.get(key);

                int expectedAmount = initialAmount - decreaseAmount;

                assertEquals(expectedAmount, Integer.valueOf(value));
            }
        }

        @Nested
        @DisplayName("with multi thread")
        class Context_With_Multi_Thread {

            @Test
            @DisplayName("does not decrease inventory by amount")
            void It_Does_Not_Decrease_Inventory_By_Amount() throws InterruptedException {
                int threadCount = 100;

                int decreaseAmount = 1;

                ExecutorService executorService = Executors.newFixedThreadPool(32);

                CountDownLatch latch = new CountDownLatch(threadCount);

                for (int i = 0; i < threadCount; i++) {
                    executorService.submit(() -> {
                        try {
                            // Perform the test
                            inventoryRepository.decreaseByAmountWithoutLock(key, decreaseAmount);
                        } catch (Exception e) {
                            System.out.println(e.getMessage());
                        } finally {
                            latch.countDown();
                        }
                    });
                }

                latch.await();

                String value = redisStringsRepository.get(key);

                assertNotEquals(0, Integer.valueOf(value)); // 테스트 통과 안함.
            }
        }
    }

    @Nested
    @DisplayName("decreaseByAmount")
    class Describe_decreaseByAmount {

        @Nested
        @DisplayName("with 1 thread")
        class Context_With_Single_Thread {

            @Test
            @DisplayName("decreases inventory by amount")
            void It_Decreases_Inventory_By_Amount() throws InterruptedException {
                int decreaseAmount = 1;

                inventoryRepository.decreaseByAmount(key, decreaseAmount);

                String value = redisStringsRepository.get(key);

                int expectedAmount = initialAmount - decreaseAmount;

                assertEquals(expectedAmount, Integer.valueOf(value));
            }
        }

        @Nested
        @DisplayName("with multi thread")
        class Context_With_Multi_Thread {

            @Test
            @DisplayName("decrease inventory by amount")
            void It_Does_Not_Decrease_Inventory_By_Amount() throws InterruptedException {
                int threadCount = 100;

                int decreaseAmount = 1;

                ExecutorService executorService = Executors.newFixedThreadPool(32);

                CountDownLatch latch = new CountDownLatch(threadCount);

                for (int i = 0; i < threadCount; i++) {
                    executorService.submit(() -> {
                        try {
                            // Perform the test
                            inventoryRepository.decreaseByAmount(key, decreaseAmount);
                        } catch (Exception e) {
                            System.out.println(e.getMessage());
                        } finally {
                            latch.countDown(); // Latch의 숫자가 1개씩 감소
                        }
                    });
                }

                latch.await(); // Latch의 숫자가 0이 될 때까지 기다리는 코드

                String value = redisStringsRepository.get(key);

                assertEquals(0, Integer.valueOf(value));
            }
        }
    }
}