[Spring] redis 분산 락 전략을 통한 동시성 처리(선착순, 더티 리드, 팬텀 리드)

Spring과 Redis를 활용한 동시성 처리 및 데이터 일관성

현대의 애플리케이션에서는 동시성 처리가 중요한 요소입니다. 특히 여러 사용자가 동시에 데이터를 수정하거나 조회하는 환경에서 데이터의 일관성을 유지하는 것은 큰 도전 과제가 됩니다. 

 

실제로 무작위 포인트(랜덤 포인트) 지급 이벤트를 개발했던 경험을 정리해보려고 글을 작성해 봅니다.

1. 동시성 처리의 필요성

동시성이란 여러 트랜잭션이 동시에 실행될 때 발생하는 현상으로, 데이터베이스에서의 읽기 및 쓰기 작업의 충돌을 관리하는 것이 중요합니다. 이러한 충돌이 발생하면 데이터의 일관성이 저해될 수 있으며, 이는 사용자 경험에 부정적인 영향을 미칠 수 있습니다.

 

2. Spring에서의 트랜잭션 격리 수준

Spring에서는 트랜잭션의 격리 수준을 설정하여 동시성 문제를 해결할 수 있습니다. 격리 수준에는 여러 종류가 있으며, 대표적으로 다음과 같은 것들이 있습니다:

● READ UNCOMMITTED: 다른 트랜잭션이 커밋하지 않은 데이터를 읽을 수 있습니다. 가장 낮은 격리 수준으로 더티 리드가 발생할 수 있습니다.
● READ COMMITTED: 커밋된 데이터만 읽을 수 있으며, 더티 리드는 방지할 수 있습니다. 하지만 팬텀 리드가 발생할 수 있습니다.
● REPEATABLE READ: 같은 트랜잭션 내에서 같은 데이터를 여러 번 읽을 경우, 항상 같은 결과를 보장합니다. 팬텀 리드는 방지하지만 성능 저하가 있을 수 있습니다.

● SERIALIZABLE: 가장 높은 격리 수준으로, 트랜잭션을 순차적으로 처리하여 데이터의 일관성을 보장합니다. 하지만 성능이 크게 저하될 수 있습니다.

3. Redis의 분산 락

Redis는 인메모리 데이터베이스로 빠른 데이터 접근이 가능하며, 분산 락을 통해 동시성 문제를 해결하는 데 유용합니다. Redis의 분산 락을 활용하면 특정 트랜잭션이 진행 중일 때 다른 트랜잭션이 해당 데이터에 접근하지 못하도록 할 수 있습니다. 이를 통해 다음과 같은 이점을 얻을 수 있습니다:

빠른 성능: Redis는 인메모리 데이터베이스이므로 높은 성능을 제공합니다.
동시성 관리: 분산 락을 통해 데이터의 동시 수정 문제를 방지할 수 있습니다.

 

---

실제 사용했던 랜덤 포인트 지급 이벤트 동시성 처리 예시 코드

Redis config

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;

@Configuration
public class RedisConfig {
    
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        return new JedisConnectionFactory();
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory());
        return template;
    }
}

 

Redis 분산 락 서비스

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Service
public class DistributedLockService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public boolean acquireLock(String lockKey, long timeout) {
        String lockValue = UUID.randomUUID().toString();
        Boolean success = redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue, timeout, TimeUnit.MILLISECONDS);
        
        if (success != null && success) {
            return true; // 락을 성공적으로 얻음
        }
        return false; // 락을 얻지 못함
    }

    public void releaseLock(String lockKey, String lockValue) {
        // 현재 락의 값과 비교하여 동일할 경우에만 락 해제
        if (lockValue.equals(redisTemplate.opsForValue().get(lockKey))) {
            redisTemplate.delete(lockKey);
        }
    }
}

 

포인트 관리 서비스

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class PointConfigService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private PointConfigRepository pointConfigRepository; // 메인 DB와 연결된 리포지토리

    // 초기값 로딩
    public void loadInitialPointConfig() {
        int initialPoints = pointConfigRepository.getDailyPointLimit();
        redisTemplate.opsForValue().set("daily_point_limit", initialPoints);
    }

    // 관리자 페이지에서 포인트 조정
    public void updateDailyPointLimit(int newLimit) {
        // 메인 DB 업데이트
        pointConfigRepository.updateDailyPointLimit(newLimit);
        // Redis 업데이트
        redisTemplate.opsForValue().set("daily_point_limit", newLimit);
    }

    // 포인트 조회
    public int getDailyPointLimit() {
        Integer limit = (Integer) redisTemplate.opsForValue().get("daily_point_limit");
        if (limit == null) {
            // Redis에 값이 없으면 메인 DB에서 조회
            limit = pointConfigRepository.getDailyPointLimit();
            // Redis에 캐시
            redisTemplate.opsForValue().set("daily_point_limit", limit);
        }
        return limit;
    }
}

 

포인트 지급 서비스

@Service
public class PointService {

    @Autowired
    private DistributedLockService distributedLockService;

    @Autowired
    private PointRepository pointRepository; // 포인트 정보를 조회할 수 있는 레포지토리

    public int getCurrentPoints(String userId) {
        // Redis에서 포인트 조회
        Integer points = redisTemplate.opsForValue().get(userId);
        if (points == null) {
            // Redis에 값이 없으면 DB에서 조회
            points = pointRepository.getCurrentPoints(userId);
            // Redis에 캐시
            redisTemplate.opsForValue().set(userId, points);
        }
        return points;
    }

    public void allocatePoints(String userId, int pointsToAllocate) {
        String lockKey = "point_lock";
        long timeout = 30000; // 30초

        if (distributedLockService.acquireLock(lockKey, timeout)) {
            try {
                // 메인 DB에서 포인트 업데이트
                pointRepository.allocatePoints(userId, pointsToAllocate);
                // Redis에서도 값 업데이트
                int currentPoints = redisTemplate.opsForValue().get(userId);
                redisTemplate.opsForValue().set(userId, currentPoints + pointsToAllocate);
            } finally {
                distributedLockService.releaseLock(lockKey, UUID.randomUUID().toString());
            }
        } else {
            // 락을 얻지 못했을 경우 처리
        }
    }
}

 

관리자 페이지에서 일일 지급 가능한 포인트 조정

public void adjustPoints(int dailyPointLimit) {
    PointConfigService pointConfigService = new PointConfigService();
    
    // 초기값 로딩
    pointConfigService.loadInitialPointConfig();
    
    // 포인트 조정
    pointConfigService.updateDailyPointLimit(dailyPointLimit); // 새로운 포인트 한도 설정
}

실제 요구사항에서 관리자 페이지를 통통 일일 지급 가능한 포인트 조정이 실시간으로 필요했어서 추가되었다.

 

4. 더티 리드와 팬텀 리드

- 더티 리드(Dirty Read)
더티 리드는 트랜잭션이 커밋되지 않은 데이터를 읽는 현상입니다. 예를 들어, 한 트랜잭션이 데이터를 수정 중일 때 다른 트랜잭션이 그 데이터를 읽으면, 수정이 완료되기 전에 잘못된 정보를 기반으로 작업을 수행할 수 있습니다. 이는 데이터의 일관성을 저해합니다.

- 팬텀 리드(Phantom Read)
팬텀 리드는 한 트랜잭션에서 특정 조건을 만족하는 데이터셋을 조회할 때, 다른 트랜잭션이 데이터를 추가하거나 삭제하여 이전에 조회한 데이터셋과 다른 결과를 얻는 현상입니다. 이는 비즈니스 로직에 오류를 초래할 수 있습니다.