Java로 메모리 캐시 직접 구현해보기: 성능 최적화를 위한 실무 가이드

Java로 메모리 캐시 직접 구현해보기: 성능 최적화를 위한 실무 가이드

 

웹 애플리케이션 성능 최적화에서 메모리 캐시는 필수적인 요소입니다.
Redis나 Memcached 같은 외부 캐시 솔루션도 좋지만, 때로는 자바 애플리케이션 내부에서 직접 메모리 캐시를 구현해야 하는 상황이 발생합니다.

이번 포스팅에서는 Java로 메모리 캐시를 직접 구현하는 방법을 단계별로 알아보겠습니다.
기본적인 HashMap 기반 캐시부터 LRU 알고리즘을 적용한 고급 캐시까지 실무에서 바로 사용할 수 있는 코드를 제공합니다.

왜 자바 메모리 캐시를 직접 구현해야 할까?

자바 메모리 캐시 구현이 필요한 이유는 다양합니다.
첫째, 외부 캐시 서버와의 네트워크 통신 오버헤드를 제거할 수 있습니다.
둘째, 애플리케이션 특성에 맞는 커스텀 캐시 정책을 적용할 수 있습니다.

특히 마이크로서비스 환경에서는 각 서비스별로 독립적인 캐시가 필요한 경우가 많습니다.
이때 자바 인메모리 캐시 구현은 매우 효과적인 해결책이 됩니다.

메모리 캐시의 주요 장점은 다음과 같습니다:

• 빠른 데이터 접근 속도 (나노초 단위)
• 네트워크 지연 시간 제거
• 애플리케이션과 동일한 JVM에서 실행되는 안정성

기본적인 HashMap 기반 캐시 구현

가장 간단한 형태의 자바 캐시 구현부터 시작해보겠습니다.
HashMap을 사용한 기본 캐시는 다음과 같이 구현할 수 있습니다.

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class SimpleMemoryCache<K, V> {
    private final Map<K, V> cache;

    public SimpleMemoryCache() {
        this.cache = new ConcurrentHashMap<>();
    }

    public void put(K key, V value) {
        cache.put(key, value);
    }

    public V get(K key) {
        return cache.get(key);
    }

    public void remove(K key) {
        cache.remove(key);
    }

    public void clear() {
        cache.clear();
    }

    public int size() {
        return cache.size();
    }
}

이 기본 구현은 동시성 문제를 해결하기 위해 ConcurrentHashMap을 사용합니다.
하지만 메모리 사용량 제한이나 만료 시간 설정 기능이 없어 실무에서는 한계가 있습니다.

TTL(Time To Live) 기능이 있는 캐시 구현

실무에서 사용하는 자바 메모리 캐시에는 데이터 만료 기능이 필수입니다.
다음은 TTL 기능을 포함한 개선된 캐시 구현입니다.

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TTLMemoryCache<K, V> {
    private final ConcurrentHashMap<K, CacheItem<V>> cache;
    private final ScheduledExecutorService cleanupExecutor;

    public TTLMemoryCache() {
        this.cache = new ConcurrentHashMap<>();
        this.cleanupExecutor = Executors.newSingleThreadScheduledExecutor();

        // 1분마다 만료된 항목 정리
        cleanupExecutor.scheduleAtFixedRate(this::cleanup, 1, 1, TimeUnit.MINUTES);
    }

    public void put(K key, V value, long ttlSeconds) {
        long expirationTime = System.currentTimeMillis() + (ttlSeconds * 1000);
        cache.put(key, new CacheItem<>(value, expirationTime));
    }

    public V get(K key) {
        CacheItem<V> item = cache.get(key);
        if (item == null || item.isExpired()) {
            cache.remove(key);
            return null;
        }
        return item.getValue();
    }

    private void cleanup() {
        long currentTime = System.currentTimeMillis();
        cache.entrySet().removeIf(entry -> entry.getValue().isExpired());
    }

    public void shutdown() {
        cleanupExecutor.shutdown();
    }

    private static class CacheItem<V> {
        private final V value;
        private final long expirationTime;

        public CacheItem(V value, long expirationTime) {
            this.value = value;
            this.expirationTime = expirationTime;
        }

        public V getValue() {
            return value;
        }

        public boolean isExpired() {
            return System.currentTimeMillis() > expirationTime;
        }
    }
}

이 구현은 각 캐시 항목에 만료 시간을 설정하고, 주기적으로 만료된 항목을 정리합니다.
실제 운영 환경에서 메모리 누수를 방지하는 중요한 기능입니다.

LRU(Least Recently Used) 알고리즘 적용

메모리 사용량을 제한하기 위해 LRU 알고리즘을 적용한 자바 캐시 구현을 살펴보겠습니다.
이는 가장 오랫동안 사용되지 않은 데이터를 우선적으로 제거하는 방식입니다.

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class LRUMemoryCache<K, V> {
    private final int maxSize;
    private final ConcurrentHashMap<K, Node<K, V>> cache;
    private final Node<K, V> head;
    private final Node<K, V> tail;
    private final ReentrantReadWriteLock lock;

    public LRUMemoryCache(int maxSize) {
        this.maxSize = maxSize;
        this.cache = new ConcurrentHashMap<>();
        this.head = new Node<>(null, null);
        this.tail = new Node<>(null, null);
        this.lock = new ReentrantReadWriteLock();

        head.next = tail;
        tail.prev = head;
    }

    public void put(K key, V value) {
        lock.writeLock().lock();
        try {
            Node<K, V> existing = cache.get(key);
            if (existing != null) {
                existing.value = value;
                moveToHead(existing);
                return;
            }

            Node<K, V> newNode = new Node<>(key, value);
            cache.put(key, newNode);
            addToHead(newNode);

            if (cache.size() > maxSize) {
                Node<K, V> lastNode = removeTail();
                cache.remove(lastNode.key);
            }
        } finally {
            lock.writeLock().unlock();
        }
    }

    public V get(K key) {
        lock.readLock().lock();
        try {
            Node<K, V> node = cache.get(key);
            if (node == null) {
                return null;
            }

            // 읽기 잠금을 해제하고 쓰기 잠금으로 업그레이드
            lock.readLock().unlock();
            lock.writeLock().lock();
            try {
                moveToHead(node);
                return node.value;
            } finally {
                lock.writeLock().unlock();
            }
        } finally {
            if (lock.readLock().tryLock()) {
                lock.readLock().unlock();
            }
        }
    }

    private void addToHead(Node<K, V> node) {
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }

    private void removeNode(Node<K, V> node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private void moveToHead(Node<K, V> node) {
        removeNode(node);
        addToHead(node);
    }

    private Node<K, V> removeTail() {
        Node<K, V> lastNode = tail.prev;
        removeNode(lastNode);
        return lastNode;
    }

    private static class Node<K, V> {
        K key;
        V value;
        Node<K, V> prev;
        Node<K, V> next;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
        }
    }
}

이 LRU 캐시 구현은 이중 연결 리스트와 HashMap을 조합하여 O(1) 시간 복잡도로 동작합니다.
메모리 사용량을 효과적으로 제한할 수 있어 실무에서 매우 유용합니다.

통계 정보와 모니터링 기능 추가

운영 환경에서는 캐시 성능을 모니터링할 수 있는 기능이 필요합니다.
다음은 통계 정보를 제공하는 고급 메모리 캐시 구현입니다.

import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.ConcurrentHashMap;

public class MonitorableMemoryCache<K, V> {
    private final ConcurrentHashMap<K, V> cache;
    private final AtomicLong hitCount;
    private final AtomicLong missCount;
    private final AtomicLong putCount;
    private final long startTime;

    public MonitorableMemoryCache() {
        this.cache = new ConcurrentHashMap<>();
        this.hitCount = new AtomicLong(0);
        this.missCount = new AtomicLong(0);
        this.putCount = new AtomicLong(0);
        this.startTime = System.currentTimeMillis();
    }

    public void put(K key, V value) {
        cache.put(key, value);
        putCount.incrementAndGet();
    }

    public V get(K key) {
        V value = cache.get(key);
        if (value != null) {
            hitCount.incrementAndGet();
        } else {
            missCount.incrementAndGet();
        }
        return value;
    }

    public CacheStatistics getStatistics() {
        long totalRequests = hitCount.get() + missCount.get();
        double hitRate = totalRequests > 0 ? (double) hitCount.get() / totalRequests : 0.0;

        return new CacheStatistics(
            hitCount.get(),
            missCount.get(),
            putCount.get(),
            hitRate,
            cache.size(),
            System.currentTimeMillis() - startTime
        );
    }

    public static class CacheStatistics {
        private final long hitCount;
        private final long missCount;
        private final long putCount;
        private final double hitRate;
        private final int currentSize;
        private final long uptime;

        public CacheStatistics(long hitCount, long missCount, long putCount, 
                             double hitRate, int currentSize, long uptime) {
            this.hitCount = hitCount;
            this.missCount = missCount;
            this.putCount = putCount;
            this.hitRate = hitRate;
            this.currentSize = currentSize;
            this.uptime = uptime;
        }

        @Override
        public String toString() {
            return String.format(
                "Cache Statistics: Hit=%d, Miss=%d, Put=%d, HitRate=%.2f%%, Size=%d, Uptime=%dms",
                hitCount, missCount, putCount, hitRate * 100, currentSize, uptime
            );
        }

        // Getter 메서드들...
        public long getHitCount() { return hitCount; }
        public long getMissCount() { return missCount; }
        public double getHitRate() { return hitRate; }
        public int getCurrentSize() { return currentSize; }
    }
}

이러한 모니터링 기능을 통해 캐시 효율성을 실시간으로 추적하고 최적화할 수 있습니다.

실무에서의 활용 예제

자바 메모리 캐시를 실제 웹 애플리케이션에서 사용하는 예제를 살펴보겠습니다.
사용자 정보를 캐싱하는 서비스 클래스 구현입니다.

@Service
public class UserCacheService {
    private final TTLMemoryCache<String, User> userCache;
    private final UserRepository userRepository;

    public UserCacheService(UserRepository userRepository) {
        this.userCache = new TTLMemoryCache<>();
        this.userRepository = userRepository;
    }

    public User getUserById(String userId) {
        // 캐시에서 먼저 조회
        User cachedUser = userCache.get(userId);
        if (cachedUser != null) {
            return cachedUser;
        }

        // 캐시 미스 시 데이터베이스에서 조회
        User user = userRepository.findById(userId);
        if (user != null) {
            // 5분간 캐시에 저장
            userCache.put(userId, user, 300);
        }

        return user;
    }

    public void updateUser(User user) {
        userRepository.save(user);
        // 캐시 무효화
        userCache.remove(user.getId());
    }

    @PreDestroy
    public void cleanup() {
        userCache.shutdown();
    }
}

이 예제는 데이터베이스 조회 성능을 크게 향상시킬 수 있는 실용적인 패턴입니다.

성능 벤치마크와 최적화 팁

자바 메모리 캐시 성능 최적화를 위한 주요 포인트들을 정리해보겠습니다.

 

동시성 처리 최적화:
ConcurrentHashMap 사용으로 읽기 성능을 극대화하되, 복잡한 연산에서는 적절한 동기화가 필요합니다.

 

메모리 사용량 모니터링:
JVM 힙 메모리 사용량을 정기적으로 모니터링하고, 캐시 크기를 적절히 제한해야 합니다.

// JVM 메모리 정보 확인
Runtime runtime = Runtime.getRuntime();
long maxMemory = runtime.maxMemory();
long totalMemory = runtime.totalMemory();
long freeMemory = runtime.freeMemory();
long usedMemory = totalMemory - freeMemory;

System.out.println("Max Memory: " + maxMemory / 1024 / 1024 + "MB");
System.out.println("Used Memory: " + usedMemory / 1024 / 1024 + "MB");

가비지 컬렉션 고려사항:
대량의 캐시 데이터는 GC에 영향을 줄 수 있으므로, 적절한 크기 제한과 만료 정책이 중요합니다.

주의사항과 한계점

자바 인메모리 캐시 구현 시 고려해야 할 주요 사항들입니다.

 

메모리 누수 방지:
애플리케이션 종료 시 캐시 리소스를 적절히 정리해야 합니다.
특히 ScheduledExecutorService 같은 백그라운드 스레드는 명시적으로 종료해야 합니다.

 

클러스터 환경에서의 한계:
여러 서버 인스턴스 간 데이터 일관성 문제가 발생할 수 있습니다.
이런 경우 Redis 같은 분산 캐시 솔루션을 고려해야 합니다.

 

대용량 데이터 처리:
매우 큰 객체나 대량의 데이터를 캐싱할 때는 메모리 사용량과 GC 성능에 주의해야 합니다.

마무리

자바로 메모리 캐시를 직접 구현하는 것은 애플리케이션 성능 최적화에 매우 효과적인 방법입니다.
기본적인 HashMap 기반 캐시부터 LRU 알고리즘이 적용된 고급 캐시까지, 상황에 맞는 적절한 구현을 선택하는 것이 중요합니다.

실무에서는 TTL 기능과 모니터링 기능을 포함한 캐시를 구현하여 안정적이고 효율적인 시스템을 구축할 수 있습니다.
다만 메모리 사용량과 GC 영향을 항상 고려하고, 필요에 따라 외부 캐시 솔루션과의 하이브리드 접근 방식도 검토해보시기 바랍니다.

이번 포스팅에서 제시한 코드들은 실제 프로젝트에서 바로 활용할 수 있도록 설계되었습니다.
각각의 구현 방식을 이해하고 프로젝트 요구사항에 맞게 커스터마이징하여 사용하시면 됩니다.