캐시 스템피드 현상 제어 (Distributed Lock, PER)

import org.redisson.api.RedissonClient
import java.util.concurrent.TimeUnit

class EventService(
    private val redissonClient: RedissonClient,
    private val eventRepository: EventRepository,
    private val cacheManager: CacheManager
) {
    fun getEventData(eventId: String): EventData? {
        val cacheKey = "event:$eventId"
        
        // 1. 캐시 조회 (Cache Hit)
        val cachedData = cacheManager.get(cacheKey)
        if (cachedData != null) return cachedData

        val lockKey = "lock:event:$eventId"
        val lock = redissonClient.getLock(lockKey)

        try {
            // 2. 락 획득 시도 (대기 시간 3초, 락 점유 시간 2초)
            val isLocked = lock.tryLock(3, 2, TimeUnit.SECONDS)
            if (isLocked) {
                // 3. Double Check: 락을 대기하던 스레드가 락을 획득한 경우, 
                // 앞선 스레드가 이미 캐시를 갱신했을 수 있으므로 다시 한번 확인합니다.
                val recheckedData = cacheManager.get(cacheKey)
                if (recheckedData != null) return recheckedData

                // 4. DB 조회 및 캐시 갱신 (단 하나의 스레드만 실행됨)
                val dbData = eventRepository.findById(eventId)
                if (dbData != null) {
                    cacheManager.set(cacheKey, dbData, 60, TimeUnit.SECONDS)
                }
                return dbData
            } else {
                // 락 획득 실패 시: 너무 많은 대기자가 있거나 락 타임아웃 발생
                // Fallback 전략 실행 (예: 예전 캐시 데이터 반환 또는 사용자에게 잠시 후 시도 안내)
                throw RuntimeException("현재 접속자가 많아 처리가 지연되고 있습니다.")
            }
        } finally {
            // 5. 락 해제 (자신이 획득한 락인지 확인 후 해제)
            if (lock.isLocked && lock.isHeldByCurrentThread) {
                lock.unlock()
            }
        }
    }
}

{
  "data": { "eventName": "초특가 할인", "items": [...] },
  "logical_expire_at": 1711680000,  // 논리적 만료 시점 (예: 5분 뒤)
  "delta": 2.5 // DB 조회에 걸리는 예상 시간 (초)
}

data class PerCachePayload<T>(
    val data: T,
    val logicalExpireAt: Long, // 논리적 만료 시간 (Epoch Milliseconds)
    val deltaMs: Long          // 데이터 연산(DB 조회 등)에 소요된 시간 (Milliseconds)
)

import org.springframework.data.redis.core.RedisTemplate
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import kotlin.math.ln
import kotlin.random.Random

class PerCacheManager(
    private val redisTemplate: RedisTemplate<String, Any>,
    // 백그라운드 비동기 갱신을 위한 전용 스레드 풀
    private val asyncExecutor: ExecutorService = Executors.newFixedThreadPool(10) 
) {
    // beta: 확률 가중치 (보통 1.0 사용, 높을수록 갱신이 더 일찍 발생)
    private val beta: Double = 1.0 

    fun <T> getWithPer(
        cacheKey: String,
        logicalTtlMs: Long,
        physicalTtlMs: Long,
        dbQueryBlock: () -> T // 캐시 미스 또는 갱신 시 실행할 DB 조회 로직
    ): T {
        val cachedValue = redisTemplate.opsForValue().get(cacheKey) as? PerCachePayload<T>

        val currentTime = System.currentTimeMillis()

        // 1. 캐시가 아예 없는 경우 (최초 접근 또는 물리적 만료)
        if (cachedValue == null) {
            return recomputeAndCache(cacheKey, logicalTtlMs, physicalTtlMs, dbQueryBlock).data
        }

        // 2. PER 공식 계산
        // currentTime >= logicalExpireAt - (deltaMs * beta * log(random))
        val randomValue = Random.nextDouble() // 0.0 ~ 1.0
        val earlyRecomputeThreshold = 
            cachedValue.logicalExpireAt - (cachedValue.deltaMs * beta * -ln(randomValue))

        if (currentTime >= earlyRecomputeThreshold) {
            // 3. 확률에 당첨되거나 이미 논리적 만료가 지난 경우: 비동기 갱신 트리거
            asyncExecutor.submit {
                try {
                    recomputeAndCache(cacheKey, logicalTtlMs, physicalTtlMs, dbQueryBlock)
                } catch (e: Exception) {
                    // 비동기 갱신 실패 로깅 (사용자 응답에는 영향을 주지 않음)
                }
            }
        }

        // 4. 기존 데이터(Stale Data 포함) 즉시 반환 -> 사용자 대기 없음(Zero Latency)
        return cachedValue.data
    }

    private fun <T> recomputeAndCache(
        cacheKey: String, 
        logicalTtlMs: Long, 
        physicalTtlMs: Long, 
        dbQueryBlock: () -> T
    ): PerCachePayload<T> {
        val startTime = System.currentTimeMillis()
        
        // 무거운 DB 쿼리 실행
        val freshData = dbQueryBlock() 
        val deltaMs = System.currentTimeMillis() - startTime

        val payload = PerCachePayload(
            data = freshData,
            logicalExpireAt = System.currentTimeMillis() + logicalTtlMs,
            deltaMs = deltaMs
        )

        // 물리적 TTL을 적용하여 Redis에 저장 (단위: 밀리초)
        redisTemplate.opsForValue().set(
            cacheKey, 
            payload, 
            java.time.Duration.ofMillis(physicalTtlMs)
        )

        return payload
    }
}

@Service
class EventService(
    private val perCacheManager: PerCacheManager,
    private val eventRepository: EventRepository
) {
    fun getEventData(eventId: String): EventData {
        return perCacheManager.getWithPer(
            cacheKey = "event:detail:$eventId",
            logicalTtlMs = 5 * 60 * 1000,  // 논리적 TTL: 5분
            physicalTtlMs = 15 * 60 * 1000, // 물리적 TTL: 15분 (논리적 만료 후 10분간 버퍼)
            dbQueryBlock = { 
                eventRepository.findComplexEventData(eventId) // 무거운 쿼리
            }
        )
    }
}

import org.springframework.data.redis.core.RedisTemplate
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import java.time.Duration
import kotlin.math.ln
import kotlin.random.Random

class PerCacheManager(
    private val redisTemplate: RedisTemplate<String, Any>,
    private val asyncExecutor: ExecutorService = Executors.newFixedThreadPool(10) 
) {
    private val beta: Double = 1.0 

    fun <T> getWithPer(
        cacheKey: String,
        logicalTtlMs: Long,
        physicalTtlMs: Long,
        dbQueryBlock: () -> T
    ): T {
        val cachedValue = redisTemplate.opsForValue().get(cacheKey) as? PerCachePayload<T>
        val currentTime = System.currentTimeMillis()

        // 1. 캐시가 아예 없는 경우 (최초 접근) - 동기 방식으로 1명이 DB 조회
        if (cachedValue == null) {
            return recomputeAndCache(cacheKey, logicalTtlMs, physicalTtlMs, dbQueryBlock).data
        }

        // 2. PER 공식 계산
        val randomValue = Random.nextDouble()
        val earlyRecomputeThreshold = 
            cachedValue.logicalExpireAt - (cachedValue.deltaMs * beta * -ln(randomValue))

        // 3. 갱신 시점이 도래한 경우
        if (currentTime >= earlyRecomputeThreshold) {
            val lockKey = "lock:recompute:$cacheKey"
            
            // 핵심: SETNX를 활용한 비동기 갱신 락 획득 시도 (TTL 5초)
            // 이미 누군가 갱신 중이라면 false를 반환하여 중복 실행을 막습니다.
            val isLocked = redisTemplate.opsForValue()
                .setIfAbsent(lockKey, "LOCKED", Duration.ofSeconds(5)) ?: false

            if (isLocked) {
                asyncExecutor.submit {
                    try {
                        recomputeAndCache(cacheKey, logicalTtlMs, physicalTtlMs, dbQueryBlock)
                    } catch (e: Exception) {
                        // 에러 로깅
                    } finally {
                        // 갱신 완료 후 락 해제 (선택 사항)
                        // 삭제하지 않고 5초 TTL 만료를 기다리게 두면, 
                        // 갱신 직후 발생할 수 있는 찰나의 중복 트리거를 더 안전하게 막을 수 있습니다.
                        redisTemplate.delete(lockKey)
                    }
                }
            }
        }

        // 4. 기존 데이터 즉시 반환 (대기열 없음)
        return cachedValue.data
    }

    // recomputeAndCache 메서드는 이전과 동일합니다.
    // ...
}