Redis Cache Stampede 방지 실전: 락, 조기만료, 이중 캐시

평시:  1,000 RPS → 99% Cache Hit → DB 10 QPS ✅
만료 시: 1,000 RPS → 0% Cache Hit → DB 1,000 QPS 💥

DB 커넥션 풀: 100개 → 900개 요청 대기
응답 시간: 5ms → 3,000ms+ (타임아웃 연쇄)

@Service
@RequiredArgsConstructor
public class CacheWithLockService {
    
    private final StringRedisTemplate redis;
    private final UserRepository userRepository;
    
    private static final long CACHE_TTL = 60;      // 초
    private static final long LOCK_TTL  = 5;        // 초
    private static final int  MAX_RETRY = 3;
    private static final long RETRY_DELAY_MS = 100;
    
    public String getUserProfile(String userId) {
        String key = "user:profile:" + userId;
        
        // 1. 캐시 조회
        String cached = redis.opsForValue().get(key);
        if (cached != null) return cached;
        
        // 2. 분산 락 시도
        String lockKey = "lock:" + key;
        String token = UUID.randomUUID().toString();
        Boolean locked = redis.opsForValue()
            .setIfAbsent(lockKey, token, LOCK_TTL, TimeUnit.SECONDS);
        
        if (Boolean.TRUE.equals(locked)) {
            try {
                // 3. Double-check: 락 획득 사이에 다른 스레드가 채웠을 수 있음
                cached = redis.opsForValue().get(key);
                if (cached != null) return cached;
                
                // 4. DB 조회 + 캐시 저장
                String fresh = loadFromDb(userId);
                redis.opsForValue().set(key, fresh, CACHE_TTL, TimeUnit.SECONDS);
                return fresh;
            } finally {
                // 5. 안전한 락 해제 (소유자 검증)
                releaseLock(lockKey, token);
            }
        }
        
        // 6. 락 획득 실패 → 짧은 대기 후 재시도
        return retryGetFromCache(key, userId);
    }
    
    private String retryGetFromCache(String key, String userId) {
        for (int i = 0; i < MAX_RETRY; i++) {
            try { Thread.sleep(RETRY_DELAY_MS); } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
            String cached = redis.opsForValue().get(key);
            if (cached != null) return cached;
        }
        // 최종 fallback: 직접 DB 조회 (stampede 방지보다 가용성 우선)
        return loadFromDb(userId);
    }
    
    private String loadFromDb(String userId) {
        return userRepository.findById(userId)
            .map(User::toJson)
            .orElse("{}");
    }
    
    /**
     * Lua 스크립트로 원자적 락 해제 (소유자 토큰 검증)
     */
    private void releaseLock(String lockKey, String token) {
        String script = """
            if redis.call("GET", KEYS[1]) == ARGV[1] then
                return redis.call("DEL", KEYS[1])
            else
                return 0
            end
            """;
        redis.execute(new DefaultRedisScript<>(script, Long.class),
            List.of(lockKey), token);
    }
}

@Service
@RequiredArgsConstructor
public class CacheWithRedissonLock {
    
    private final RedissonClient redisson;
    private final StringRedisTemplate redis;
    
    public String getUserProfile(String userId) {
        String key = "user:profile:" + userId;
        
        String cached = redis.opsForValue().get(key);
        if (cached != null) return cached;
        
        RLock lock = redisson.getLock("lock:" + key);
        
        try {
            // waitTime=3초, leaseTime=5초 (자동 만료)
            boolean locked = lock.tryLock(3, 5, TimeUnit.SECONDS);
            
            if (locked) {
                try {
                    // Double-check
                    cached = redis.opsForValue().get(key);
                    if (cached != null) return cached;
                    
                    String fresh = loadFromDb(userId);
                    redis.opsForValue().set(key, fresh, 60, TimeUnit.SECONDS);
                    return fresh;
                } finally {
                    if (lock.isHeldByCurrentThread()) {
                        lock.unlock();
                    }
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        // 락 타임아웃 → fallback
        return loadFromDb(userId);
    }
}

/**
 * "Optimal Probabilistic Cache Stampede Prevention" (Vattani et al.) 구현
 * 
 * 만료까지 남은 시간이 적을수록 갱신 확률이 높아짐
 * P(갱신) = 1 - exp(-delta * beta / ttlRemaining)
 *   delta = 마지막 갱신에 걸린 시간 (ms)
 *   beta  = 튜닝 파라미터 (기본 1.0)
 */
@Component
@RequiredArgsConstructor
public class XFetchCacheService {
    
    private final StringRedisTemplate redis;
    private static final double BETA = 1.0;
    
    /**
     * 캐시 값과 메타데이터를 함께 저장
     * value 형식: {data}|{computeTimeMs}|{createdAtMs}
     */
    public String getWithXFetch(String key, long ttlSeconds,
                                 Supplier<String> loader) {
        String raw = redis.opsForValue().get(key);
        
        if (raw != null) {
            String[] parts = raw.split("\\|", 3);
            String data = parts[0];
            double computeTime = Double.parseDouble(parts[1]);
            long createdAt = Long.parseLong(parts[2]);
            
            long ttlRemaining = ttlSeconds * 1000 
                - (System.currentTimeMillis() - createdAt);
            
            // 조기 갱신 확률 계산
            if (ttlRemaining > 0 && !shouldRefresh(computeTime, ttlRemaining)) {
                return data;  // 아직 갱신 불필요
            }
        }
        
        // 갱신 실행 (락과 조합 가능)
        long start = System.currentTimeMillis();
        String fresh = loader.get();
        long computeMs = System.currentTimeMillis() - start;
        
        String packed = fresh + "|" + computeMs + "|" + System.currentTimeMillis();
        redis.opsForValue().set(key, packed, ttlSeconds, TimeUnit.SECONDS);
        
        return fresh;
    }
    
    private boolean shouldRefresh(double computeTimeMs, long ttlRemainingMs) {
        // delta * beta * (-log(rand)) > ttlRemaining → 갱신
        double random = Math.random();
        if (random == 0) random = 0.0001;
        double threshold = computeTimeMs * BETA * (-Math.log(random));
        return threshold > ttlRemainingMs;
    }
}

@Component
public class JitteredCacheWriter {
    
    private static final ThreadLocalRandom random = ThreadLocalRandom.current();
    
    /**
     * TTL에 ±20% 랜덤 지터를 추가
     * baseTtl=60초 → 실제 TTL은 48~72초 사이
     */
    public void setWithJitter(StringRedisTemplate redis,
                               String key, String value, long baseTtlSeconds) {
        long jitter = (long) (baseTtlSeconds * 0.2 * (random.nextDouble() * 2 - 1));
        long actualTtl = Math.max(baseTtlSeconds + jitter, 1);
        redis.opsForValue().set(key, value, actualTtl, TimeUnit.SECONDS);
    }
}

@Configuration
public class TwoLevelCacheConfig {
    
    /**
     * L1: Caffeine (로컬, 초고속, 짧은 TTL)
     * L2: Redis (공유, 긴 TTL)
     */
    @Bean
    public Cache<String, String> localCache() {
        return Caffeine.newBuilder()
            .maximumSize(10_000)             // 최대 10,000 엔트리
            .expireAfterWrite(10, TimeUnit.SECONDS)  // 10초 TTL
            .recordStats()                   // 모니터링용 통계
            .build();
    }
}

@Service
@RequiredArgsConstructor
@Slf4j
public class TwoLevelCacheService {
    
    private final Cache<String, String> localCache;   // L1
    private final StringRedisTemplate redis;           // L2
    private final MeterRegistry meterRegistry;
    
    private static final long L2_TTL_SECONDS = 300;   // 5분
    
    public String get(String key, Supplier<String> loader) {
        // L1 조회
        String v = localCache.getIfPresent(key);
        if (v != null) {
            meterRegistry.counter("cache.l1.hit").increment();
            return v;
        }
        meterRegistry.counter("cache.l1.miss").increment();
        
        // L2 조회
        v = redis.opsForValue().get(key);
        if (v != null) {
            meterRegistry.counter("cache.l2.hit").increment();
            localCache.put(key, v);  // L1에 승격
            return v;
        }
        meterRegistry.counter("cache.l2.miss").increment();
        
        // DB 조회 (락 조합 가능)
        v = loader.get();
        if (v != null) {
            // L2 → L1 순서로 저장
            redis.opsForValue().set(key, v, 
                L2_TTL_SECONDS + jitter(), TimeUnit.SECONDS);
            localCache.put(key, v);
        }
        
        return v;
    }
    
    /**
     * 무효화: L1 + L2 모두 삭제 + Pub/Sub으로 다른 인스턴스 L1도 무효화
     */
    public void invalidate(String key) {
        redis.delete(key);
        localCache.invalidate(key);
        // 다른 인스턴스의 L1도 무효화
        redis.convertAndSend("cache:invalidate", key);
    }
    
    private long jitter() {
        return ThreadLocalRandom.current().nextLong(-60, 61);
    }
}

@Component
@RequiredArgsConstructor
@Slf4j
public class CacheInvalidationListener {
    
    private final Cache<String, String> localCache;
    
    @Bean
    public RedisMessageListenerContainer listenerContainer(
            RedisConnectionFactory factory) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(factory);
        container.addMessageListener(
            (message, pattern) -> {
                String key = new String(message.getBody());
                localCache.invalidate(key);
                log.debug("L1 invalidated via pub/sub: {}", key);
            },
            new ChannelTopic("cache:invalidate")
        );
        return container;
    }
}

@Service
@RequiredArgsConstructor
public class StaleWhileRevalidateCache {
    
    private final StringRedisTemplate redis;
    private final TaskExecutor asyncExecutor;
    
    /**
     * 두 개의 TTL을 사용:
     * - stale TTL (데이터 키): 실제 데이터 보관 기간 (긴 TTL)
     * - fresh TTL (메타 키):  "신선" 판정 기간 (짧은 TTL)
     * 
     * fresh 만료 → stale 데이터 반환 + 비동기 갱신
     */
    public String get(String key, long freshSeconds, long staleSeconds,
                       Supplier<String> loader) {
        
        String data = redis.opsForValue().get("data:" + key);
        Boolean isFresh = redis.hasKey("fresh:" + key);
        
        if (data != null && Boolean.TRUE.equals(isFresh)) {
            return data;  // 신선한 데이터
        }
        
        if (data != null) {
            // Stale 데이터 즉시 반환 + 백그라운드 갱신
            asyncExecutor.execute(() -> refresh(key, freshSeconds, staleSeconds, loader));
            return data;
        }
        
        // 둘 다 없으면 동기 로드
        return refresh(key, freshSeconds, staleSeconds, loader);
    }
    
    private String refresh(String key, long freshSec, long staleSec,
                            Supplier<String> loader) {
        String fresh = loader.get();
        if (fresh != null) {
            redis.opsForValue().set("data:" + key, fresh, staleSec, TimeUnit.SECONDS);
            redis.opsForValue().set("fresh:" + key, "1", freshSec, TimeUnit.SECONDS);
        }
        return fresh;
    }
}

@Component
public class SingleflightCache {
    
    /**
     * ConcurrentHashMap + CompletableFuture로 구현
     * 같은 키에 대해 동시에 여러 요청이 와도 DB 조회는 1번만
     */
    private final ConcurrentHashMap<String, CompletableFuture<String>> inflight
        = new ConcurrentHashMap<>();
    
    public String getOrLoad(String key, Supplier<String> loader) {
        CompletableFuture<String> future = inflight.computeIfAbsent(key, k -> {
            CompletableFuture<String> f = CompletableFuture.supplyAsync(loader::get);
            f.whenComplete((result, ex) -> inflight.remove(k));
            return f;
        });
        
        try {
            return future.get(5, TimeUnit.SECONDS);
        } catch (Exception e) {
            inflight.remove(key);
            throw new RuntimeException("Cache load failed for: " + key, e);
        }
    }
}

@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    @Primary
    public CacheManager redisCacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration
            .defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10))
            .serializeValuesWith(
                RedisSerializationContext.SerializationPair
                    .fromSerializer(new GenericJackson2JsonRedisSerializer()))
            .disableCachingNullValues();
        
        // 캐시별 TTL 차등 설정
        Map<String, RedisCacheConfiguration> perCacheConfig = Map.of(
            "products",  config.entryTtl(Duration.ofHours(1)),
            "users",     config.entryTtl(Duration.ofMinutes(30)),
            "rankings",  config.entryTtl(Duration.ofMinutes(5)),
            "configs",   config.entryTtl(Duration.ofHours(24))
        );
        
        return RedisCacheManager.builder(factory)
            .cacheDefaults(config)
            .withInitialCacheConfigurations(perCacheConfig)
            .transactionAware()
            .build();
    }
    
    @Bean
    public CacheManager caffeineCacheManager() {
        CaffeineCacheManager manager = new CaffeineCacheManager();
        manager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(5_000)
            .expireAfterWrite(10, TimeUnit.SECONDS)
            .recordStats());
        return manager;
    }
}

@Service
@RequiredArgsConstructor
public class ProductService {
    
    private final ProductRepository productRepo;
    
    @Cacheable(value = "products", key = "#productId",
               unless = "#result == null")
    public ProductDto getProduct(Long productId) {
        return productRepo.findById(productId)
            .map(ProductDto::from)
            .orElse(null);
    }
    
    @CachePut(value = "products", key = "#product.id")
    public ProductDto updateProduct(ProductUpdateRequest product) {
        Product saved = productRepo.save(product.toEntity());
        return ProductDto.from(saved);
    }
    
    @CacheEvict(value = "products", key = "#productId")
    public void deleteProduct(Long productId) {
        productRepo.deleteById(productId);
    }
    
    /**
     * 전체 무효화 (주의해서 사용)
     */
    @CacheEvict(value = "products", allEntries = true)
    @Scheduled(cron = "0 0 3 * * *")  // 매일 새벽 3시
    public void evictAllProductCache() {
        // 로그만 남김
    }
}

@Component
@RequiredArgsConstructor
public class CacheMetrics {
    
    private final MeterRegistry registry;
    
    /**
     * 캐시 히트율, miss율, 지연 시간 기록
     */
    public <T> T recordCacheAccess(String cacheName, String key,
                                    Supplier<T> cacheGet, Supplier<T> loader) {
        Timer.Sample sample = Timer.start(registry);
        
        T cached = cacheGet.get();
        if (cached != null) {
            registry.counter("cache_access",
                "cache", cacheName, "result", "hit").increment();
            sample.stop(registry.timer("cache_latency",
                "cache", cacheName, "result", "hit"));
            return cached;
        }
        
        registry.counter("cache_access",
            "cache", cacheName, "result", "miss").increment();
        
        T fresh = loader.get();
        sample.stop(registry.timer("cache_latency",
            "cache", cacheName, "result", "miss"));
        
        return fresh;
    }
}

# prometheus-rules.yaml
groups:
  - name: cache-stampede-alerts
    rules:
      # 캐시 히트율 급락 감지
      - alert: CacheHitRateDrop
        expr: |
          (
            sum(rate(cache_access_total{result="hit"}[5m])) by (cache)
            /
            sum(rate(cache_access_total[5m])) by (cache)
          ) < 0.8
        for: 2m
        labels:
          severity: warning
        annotations:
          summary: "캐시 히트율 80% 미만 ({{ $labels.cache }})"
          description: "현재 히트율: {{ $value | humanizePercentage }}"
      
      # Cache miss 후 DB 지연 급증
      - alert: CacheMissLatencySpike
        expr: |
          histogram_quantile(0.99,
            rate(cache_latency_seconds_bucket{result="miss"}[5m])
          ) > 1.0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "캐시 miss 시 DB 조회 p99 > 1초"
          
      # Redis 메모리 사용률
      - alert: RedisMemoryHigh
        expr: redis_memory_used_bytes / redis_memory_max_bytes > 0.85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Redis 메모리 85% 초과 — eviction 임박"
      
      # Hot Key 감지 (초당 1000회 이상 접근)
      - alert: HotKeyDetected
        expr: |
          topk(5,
            sum(rate(cache_access_total[1m])) by (key)
          ) > 1000
        for: 3m
        labels:
          severity: info
        annotations:
          summary: "Hot Key 감지: {{ $labels.key }}"

@Component
@RequiredArgsConstructor
@Slf4j
public class CacheWarmer {
    
    private final StringRedisTemplate redis;
    private final ProductRepository productRepo;
    
    /**
     * 애플리케이션 시작 시 핫 키 사전 로드
     */
    @EventListener(ApplicationReadyEvent.class)
    public void warmUpCache() {
        log.info("Cache warming 시작...");
        
        // Top 100 인기 상품 사전 로드
        List<Product> hotProducts = productRepo.findTop100ByOrderByViewCountDesc();
        
        // Pipeline으로 일괄 저장 (RTT 최소화)
        redis.executePipelined((RedisCallback<Object>) connection -> {
            for (Product p : hotProducts) {
                byte[] key = ("product:" + p.getId()).getBytes();
                byte[] value = p.toJson().getBytes();
                connection.stringCommands().setEx(key, 3600, value);
            }
            return null;
        });
        
        log.info("Cache warming 완료: {} 키 로드", hotProducts.size());
    }
}

□ TTL을 모든 키에 동일하게 설정하지 않았는가? → Jitter 추가
□ 락 TTL이 DB 쿼리 시간보다 짧지 않은가? → 락 TTL > max query time
□ 락 해제 시 소유자 토큰을 검증하는가? → Lua 스크립트 필수
□ 캐시 miss fallback에 타임아웃을 설정했는가? → DB 타임아웃 + 서킷브레이커
□ L1 캐시가 너무 크지 않은가? → GC 압박 모니터링
□ Null 값도 캐시하는가? → Cache Penetration 방지 (짧은 TTL로)
□ 캐시 무효화 시 L1 + L2 모두 처리하는가? → Pub/Sub 동기화
□ 배포 시 캐시 warming을 하는가? → Cold Start 방지