#27 stock: race condition solution 2 - db(optimistic lock)

stock/src/main/java/com/example/stock/domain/Stock.java

@@ -4,10 +4,7 @@ import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
+import javax.persistence.*;
 
 @Entity
 @NoArgsConstructor
@@ -19,6 +16,9 @@ public class Stock {
 
     private Long productId;
 
+    @Version
+    private Long version;
+
     public Stock(Long productId, Long quantity) {
         this.productId = productId;
         this.quantity = quantity;

stock/src/main/java/com/example/stock/facade/OptimisticLockStockFacade.java

@@ -0,0 +1,25 @@
+package com.example.stock.facade;
+
+import com.example.stock.service.OptimisticLockStockService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class OptimisticLockStockFacade {
+
+    private final OptimisticLockStockService optimisticLockStockService;
+
+    public void decrease(Long id, Long quantity) throws InterruptedException {
+        while (true) {
+            try {
+                optimisticLockStockService.decrease(id, quantity);
+
+                break;
+            } catch (Exception e) {
+                Thread.sleep(50);
+            }
+        }
+
+    }
+}

stock/src/main/java/com/example/stock/repository/StockRepository.java

@@ -12,4 +12,8 @@ public interface StockRepository extends JpaRepository<Stock, Long> {
     @Lock(value = LockModeType.PESSIMISTIC_WRITE)
     @Query("select s from Stock s where s.id =:id")
     Stock findByIdWithPessimisticLock(Long id);
+
+    @Lock(value = LockModeType.OPTIMISTIC)
+    @Query("select s from Stock s where s.id =:id")
+    Stock findByIdWithOptimisticLock(Long id);
 }

stock/src/main/java/com/example/stock/service/OptimisticLockStockService.java

@@ -0,0 +1,23 @@
+package com.example.stock.service;
+
+import com.example.stock.domain.Stock;
+import com.example.stock.repository.StockRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+public class OptimisticLockStockService {
+
+    private final StockRepository stockRepository;
+
+    @Transactional
+    public void decrease(Long id, Long quantity) {
+        Stock stock = stockRepository.findByIdWithOptimisticLock(id);
+
+        stock.decrease(quantity);
+
+        stockRepository.saveAndFlush(stock);
+    }
+}

stock/src/test/java/com/example/stock/facade/OptimisticLockStockFacadeTest.java

@@ -0,0 +1,65 @@
+package com.example.stock.facade;
+
+import com.example.stock.domain.Stock;
+import com.example.stock.repository.StockRepository;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@SpringBootTest
+class OptimisticLockStockFacadeTest {
+
+    @Autowired
+    private OptimisticLockStockFacade optimisticLockStockFacade;
+
+    @Autowired
+    private StockRepository stockRepository;
+
+    @BeforeEach
+    public void before() {
+        Stock stock = new Stock(1L, 100L);
+
+        stockRepository.saveAndFlush(stock);
+    }
+
+    @AfterEach
+    public void after() {
+        stockRepository.deleteAll();
+    }
+
+    @Test
+    public void 동시에_100개의_요청_optimistic_lock() throws InterruptedException {
+        int threadCount = 100;
+        ExecutorService executorService = Executors.newFixedThreadPool(32);
+
+        CountDownLatch latch = new CountDownLatch(threadCount);
+
+        for (int i = 0; i < threadCount; i++) {
+            executorService.submit(() -> {
+                try {
+                    optimisticLockStockFacade.decrease(1L, 1L);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                } finally {
+                    latch.countDown();
+                }
+            });
+        }
+
+        latch.await();
+
+        Stock stock = stockRepository.findById(1L).orElseThrow();
+
+        // 100 - (1 * 100) = 0
+        assertEquals(0L, stock.getQuantity());
+    }
+
+}