캐시 데코레이터: lru_cache와 cache

지난 글에서 @property와 cached_property를 살펴봤다. 이번 글에서는 함수 결과를 캐싱하는 functools.lru_cache와 cache를 깊이 다룬다. 재귀 함수 최적화부터 API 응답 캐싱까지 실무에서 자주 쓰이는 패턴이다.

메모이제이션이란

메모이제이션(memoization)은 함수를 처음 호출한 결과를 저장해 두고, 같은 인자로 다시 호출되면 저장된 결과를 반환하는 최적화 기법이다. 순수 함수(같은 입력 → 항상 같은 출력)에만 올바르게 적용된다.

# 캐시 없이 피보나치: O(2^n) 호출 폭발
def fib(n):
    if n < 2: return n
    return fib(n-1) + fib(n-2)

# fib(40) → 약 2억 번 호출

fib(40) 하나 계산에 약 2억 번의 재귀 호출이 발생한다. fib(38)이 반복 계산되기 때문이다.

functools.cache (Python 3.9+)

from functools import cache

@cache
def fib(n: int) -> int:
    if n < 2: return n
    return fib(n-1) + fib(n-2)

print(fib(100))   # 즉시 계산, 100번만 호출

@cache는 lru_cache(maxsize=None)의 단순 별칭이다. 크기 제한이 없으므로 모든 결과가 영구 저장된다. 크기 추적 오버헤드가 없어 lru_cache보다 약간 빠르다.

functools.lru_cache (Python 3.2+)

from functools import lru_cache

@lru_cache(maxsize=128)
def fetch_user(user_id: int) -> dict:
    return db.query("SELECT ...", user_id)

info = fetch_user.cache_info()
# CacheInfo(hits=42, misses=8, maxsize=128, currsize=8)

fetch_user.cache_clear()   # 캐시 전체 비우기

maxsize=128이면 최근 128개의 (인자, 결과) 쌍을 저장한다. 128개를 초과하면 LRU(Least Recently Used) 알고리즘으로 가장 오래 전에 쓰인 항목을 제거한다.

cache_info()는 캐시 통계를 반환한다. hits(캐시 적중), misses(캐시 미적중), maxsize, currsize를 확인할 수 있다.

LRU 동작 원리

LRU 캐시는 내부적으로 딕셔너리 + 이중 연결 리스트로 구현된다. 캐시에 접근할 때마다 해당 항목이 리스트의 앞으로 이동한다. 리스트의 끝이 “가장 오래 안 쓰인” 항목이다.

# maxsize=3 캐시 예시
# 초기: []
fib(1) → [1]
fib(2) → [2, 1]
fib(3) → [3, 2, 1]
fib(4) → [4, 3, 2]  ← 1 제거 (LRU)
fib(2) → [2, 4, 3]  ← 2 MRU(앞)으로 이동
fib(1) → [1, 2, 4]  ← 3 제거 (LRU), 1 재계산

인자는 hashable이어야 한다

lru_cache/cache는 인자를 딕셔너리 키로 쓰므로 모든 인자가 hashable이어야 한다.

@cache
def process_list(data: list) -> int:   # TypeError!
    return sum(data)

# 리스트는 unhashable → 에러
process_list([1, 2, 3])

# 해결: tuple로 변환
@cache
def process_list(data: tuple) -> int:
    return sum(data)

process_list(tuple([1, 2, 3]))   # OK

딕셔너리를 캐시하고 싶다면 frozenset(d.items())나 별도의 직렬화가 필요하다.

메서드에 cache 적용 시 메모리 누수

lru_cache를 인스턴스 메서드에 직접 쓰면 self가 캐시 키에 포함되어 메모리 누수가 생긴다.

class MyClass:
    @lru_cache(maxsize=None)   # 위험!
    def compute(self, x):
        return x * 2

obj = MyClass()
obj.compute(1)
# 캐시가 obj를 참조 → obj가 gc되지 않음
del obj   # 실제로 메모리 해제 안 됨

인스턴스 메서드에는 cached_property 또는 인스턴스별 캐시를 직접 구현한다.

from functools import cached_property

class MyClass:
    @cached_property
    def expensive_value(self):
        return compute_something()
    # 인스턴스 __dict__에 저장 → gc와 함께 해제됨

캐시 무효화

lru_cache는 TTL(Time-to-Live) 지원이 없다. 시간 기반 무효화가 필요하면 직접 구현해야 한다.

import time
from functools import wraps

def ttl_cache(seconds=60, maxsize=128):
    def decorator(func):
        cache = {}
        @wraps(func)
        def wrapper(*args):
            now = time.monotonic()
            if args in cache:
                result, ts = cache[args]
                if now - ts < seconds:
                    return result
            result = func(*args)
            cache[args] = (result, now)
            if len(cache) > maxsize:
                oldest = min(cache, key=lambda k: cache[k][1])
                del cache[oldest]
            return result
        wrapper.cache_clear = cache.clear
        return wrapper
    return decorator

@ttl_cache(seconds=300)
def get_config(key):
    return load_from_db(key)

---

지난 글: property 데코레이터 완전 이해

다음 글: deprecated 경고 데코레이터

읽어주셔서 감사합니다. 😊