Evaluating Redisson Distributed Lock (tryLock) to prevent overselling in a Spring Boot E-commerce app

Question

I am building a mid-sized E-commerce web application using Spring Boot, Spring Data JPA (MySQL), and Redis. I need to handle concurrent order creations and prevent overselling (race conditions) when multiple users try to buy the same product at the exact same time. Currently, I am considering using Redisson Distributed Lock with a fail-fast approach (tryLock) wrapping the database transaction. Here is the simplified architecture of my OrderService:


```
@Service
@RequiredArgsConstructor
public class OrderService {

    private final RedissonClient redissonClient;
    private final TransactionTemplate transactionTemplate;
    
    public OrderResponse createOrder(OrderRequest request) {
        // 1. Sort product IDs to prevent deadlocks
        List sortedIds = getSortedProductIds(request);
        
        // 2. Create MultiLock
        RLock multiLock = getRedissonMultiLock(sortedIds);
        
        boolean isLocked = false;
        try {
            // 3. Try-lock with fail-fast (wait max 2 seconds)
            isLocked = multiLock.tryLock(2, TimeUnit.SECONDS);
            
            if (!isLocked) {
                // Return immediately if the system is busy under high contention
                throw new SystemBusyException("System is busy, please try again later.");
            }
            
            // 4. Execute DB Transaction inside the lock
            return transactionTemplate.execute(status -> {
                // Read stock from MySQL -> Check stock -> Deduct stock -> Save Order
                return executeOrderCreationDBLogic(request);
            });
            
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("Thread interrupted");
        } finally {
            if (isLocked) {
                multiLock.unlock();
            }
        }
    }
}

```
My technical concerns and questions are:

Performance Bottleneck under High Contention: If 10,000 users click "Checkout" for the exact same product simultaneously (e.g., a Flash Sale), they will wait sequentially. With my 2-second tryLock wait time, only a few dozen requests will succeed, and the rest will fail-fast. Is this considered a good protective pattern (Circuit Breaker-like) or an anti-pattern for UX?
Transaction Scope: Is it perfectly safe to wrap the Spring TransactionTemplate inside the Redis lock as shown above to ensure the DB commit finishes before the lock is released?

Optimistic Locking vs Distributed Locking: For a mid-sized app, is using @Version (Optimistic Locking) on the Product entity inside MySQL a better/simpler approach than introducing Redisson network overhead, assuming I want to avoid database transaction rollbacks as much as possible? Any insights from a System Design perspective would be highly appreciated!

Evaluating Redisson Distributed Lock (tryLock) to prevent overselling in a Spring Boot E-commerce app

Related Questions

Same Tag Questions

Popular Questions

0 Answers