C++ 캐시 교체 알고리즘 총정리 | FIFO·LRU·LFU·Clock·MRU·OPT 완벽 비교
이 글의 핵심
LRU와 비슷한 캐시 교체 정책을 한 번에 정리합니다. FIFO·LFU·MRU·Random·Clock(Second Chance)·OPT의 직관·장단점·복잡도·실무 사용처, C++ 구현 예제, Redis·OS 페이지와의 연결까지.
들어가며
LRU(Least Recently Used)는 대표적인 캐시 교체(cache replacement) 정책이지만, 같은 문제를 푸는 다른 규칙들이 많습니다. 이 글에서는 LRU와 목적이 비슷한 정책들을 나란히 놓고, 직관·장단점·구현 난이도·쓰임을 정리합니다.
이 글을 읽으면
- FIFO, LRU, LFU, MRU, Random, Clock, OPT의 차이를 이해합니다
- 각 정책의 시간 복잡도와 구현 난이도를 비교합니다
- 워크로드에 맞는 정책을 선택하는 기준을 익힙니다
- C++ 구현 예제와 실무 사례를 확인합니다
실전 경험에서 배운 교훈
이 기술을 실무 프로젝트에 처음 도입했을 때, 공식 문서만으로는 알 수 없었던 많은 함정들이 있었습니다. 특히 프로덕션 환경에서 발생하는 엣지 케이스들은 로컬 개발 환경에서는 재현조차 되지 않았죠.
가장 어려웠던 점은 성능 최적화였습니다. 처음엔 “동작만 하면 되겠지”라고 생각했지만, 실제 사용자 트래픽이 몰리면서 병목 지점들이 하나씩 드러났습니다. 특히 데이터베이스 쿼리 최적화, 캐싱 전략, 에러 핸들링 구조 등은 여러 번의 장애를 겪으면서 개선해 나갔습니다.
이 글에서는 그런 시행착오를 통해 얻은 실전 노하우와, “이렇게 하면 안 된다”는 교훈들을 함께 정리했습니다. 특히 트러블슈팅 섹션은 실제 장애 대응 경험을 바탕으로 작성했으니, 비슷한 문제를 마주했을 때 참고하시면 도움이 될 것입니다.
캐시 교체 문제
용량이 정해진 캐시에 새 항목을 넣어야 하는데 자리가 없을 때, 기존 항목 하나를 골라 제거(eviction) 해야 합니다. “무엇을 지울까?”를 정하는 것이 곧 알고리즘입니다.
flowchart LR
A[캐시 가득] --> B{교체 정책}
B --> C[FIFO]
B --> D[LRU]
B --> E[LFU]
B --> F[Clock 등]
주요 정책
1. FIFO (First In First Out)
가장 먼저 들어온 항목을 제거합니다. 줄 서기와 같습니다.
| 항목 | 내용 |
|---|---|
| 직관 | 구현이 단순함 |
| 복잡도 | 큐 + 맵이면 삽입·삭제 평균 O(1) |
| 단점 | 자주 쓰는데도 “옛날에 들어왔다”는 이유만으로 지워질 수 있음 |
| 참고 | Bélády 변칙(anomaly) - 프레임 수가 늘어도 페이지 폴트가 늘 수 있음 |
2. LRU (Least Recently Used)
가장 오래 “사용되지 않은” 항목을 제거합니다.
| 항목 | 내용 |
|---|---|
| 직관 | 시간 지역성에 잘 맞음 |
| 복잡도 | list + unordered_map으로 O(1) |
| 장점 | 범용적으로 좋은 성능 |
| 단점 | 한 번만 스캔하고 끝인 패턴에서는 불리 |
3. LFU (Least Frequently Used)
참조 횟수가 가장 적은 항목을 제거합니다.
| 항목 | 내용 |
|---|---|
| 직관 | 인기 있는 키는 오래 유지 |
| 복잡도 | 이중 구조 필요 (LeetCode 460 수준) |
| 장점 | 진짜 인기 항목 보호 |
| 단점 | ”stale popular” 문제 (예전에 많이 쓰였지만 지금은 안 쓰는 항목) |
4. MRU (Most Recently Used)
가장 최근에 사용한 항목을 제거합니다. LRU와 반대입니다.
| 항목 | 내용 |
|---|---|
| 직관 | 순차 스캔에 유리 |
| 복잡도 | LRU와 유사 |
| 쓰임 | 특수 워크로드 (순차 스캔) |
5. Random
무작위로 하나 지웁니다.
| 항목 | 내용 |
|---|---|
| 직관 | 구현 단순 |
| 복잡도 | O(1) |
| 장점 | 락 경합 최소화 |
| 단점 | 품질 기대치 낮음 |
6. Clock (Second Chance)
OS 페이지 교체에서 흔한 LRU 근사입니다.
| 항목 | 내용 |
|---|---|
| 직관 | 참조 비트 기반 |
| 복잡도 | O(1) ~ O(n) |
| 장점 | 메타데이터 비용 적음 |
| 쓰임 | OS 페이지, 임베디드 |
7. OPT / MIN (이론적 최적)
앞으로 가장 오랫동안 쓰이지 않을 페이지를 제거합니다.
| 항목 | 내용 |
|---|---|
| 직관 | 미래 참조 필요 |
| 복잡도 | 이론만 |
| 쓰임 | 성능 상한 분석 |
실전 구현
1) FIFO 캐시
#include <cstddef>
#include <optional>
#include <queue>
#include <stdexcept>
#include <unordered_map>
#include <utility>
#include <iostream>
template <typename K, typename V, typename Hash = std::hash<K>>
class FIFOCache {
public:
explicit FIFOCache(std::size_t capacity) : capacity_(capacity) {
if (capacity_ == 0) throw std::invalid_argument("capacity > 0");
}
std::optional<V> get(const K& key) {
auto it = map_.find(key);
if (it == map_.end()) return std::nullopt;
return it->second;
}
void put(const K& key, V value) {
auto it = map_.find(key);
if (it != map_.end()) {
it->second = std::move(value);
return;
}
if (map_.size() >= capacity_) {
evict_fifo();
}
order_.push(key);
map_.emplace(key, std::move(value));
}
private:
void evict_fifo() {
while (!order_.empty()) {
K victim = order_.front();
order_.pop();
if (map_.erase(victim)) return;
}
}
std::size_t capacity_;
std::queue<K> order_;
std::unordered_map<K, V, Hash> map_;
};
int main() {
FIFOCache<int, std::string> cache(3);
cache.put(1, "one");
cache.put(2, "two");
cache.put(3, "three");
std::cout << cache.get(1).value() << std::endl; // one
cache.put(4, "four"); // 1 제거 (FIFO)
std::cout << (cache.get(1).has_value() ? "있음" : "없음") << std::endl; // 없음
return 0;
}2) LRU 캐시
#include <list>
#include <unordered_map>
#include <optional>
#include <iostream>
template <typename K, typename V>
class LRUCache {
public:
explicit LRUCache(size_t capacity) : capacity_(capacity) {}
std::optional<V> get(const K& key) {
auto it = map_.find(key);
if (it == map_.end()) return std::nullopt;
// 맨 앞으로 이동
list_.splice(list_.begin(), list_, it->second);
return it->second->second;
}
void put(const K& key, V value) {
auto it = map_.find(key);
if (it != map_.end()) {
it->second->second = std::move(value);
list_.splice(list_.begin(), list_, it->second);
return;
}
if (map_.size() >= capacity_) {
auto victim = list_.back().first;
list_.pop_back();
map_.erase(victim);
}
list_.emplace_front(key, std::move(value));
map_[key] = list_.begin();
}
private:
size_t capacity_;
std::list<std::pair<K, V>> list_;
std::unordered_map<K, typename std::list<std::pair<K, V>>::iterator> map_;
};
int main() {
LRUCache<int, std::string> cache(3);
cache.put(1, "one");
cache.put(2, "two");
cache.put(3, "three");
cache.get(1); // 1 사용
cache.put(4, "four"); // 2 제거 (LRU)
std::cout << (cache.get(2).has_value() ? "있음" : "없음") << std::endl; // 없음
return 0;
}3) Clock (Second Chance) 알고리즘
#include <vector>
#include <unordered_map>
#include <optional>
#include <iostream>
template <typename K, typename V>
class ClockCache {
private:
struct Entry {
K key;
V value;
bool referenced;
};
size_t capacity_;
size_t hand_;
std::vector<Entry> entries_;
std::unordered_map<K, size_t> map_;
public:
explicit ClockCache(size_t capacity)
: capacity_(capacity), hand_(0) {
entries_.reserve(capacity);
}
std::optional<V> get(const K& key) {
auto it = map_.find(key);
if (it == map_.end()) return std::nullopt;
entries_[it->second].referenced = true;
return entries_[it->second].value;
}
void put(const K& key, V value) {
auto it = map_.find(key);
if (it != map_.end()) {
entries_[it->second].value = std::move(value);
entries_[it->second].referenced = true;
return;
}
if (entries_.size() < capacity_) {
size_t index = entries_.size();
entries_.push_back({key, std::move(value), true});
map_[key] = index;
} else {
evict_clock(key, std::move(value));
}
}
private:
void evict_clock(const K& key, V value) {
while (true) {
if (!entries_[hand_].referenced) {
K victim = entries_[hand_].key;
map_.erase(victim);
entries_[hand_] = {key, std::move(value), true};
map_[key] = hand_;
hand_ = (hand_ + 1) % capacity_;
return;
}
entries_[hand_].referenced = false;
hand_ = (hand_ + 1) % capacity_;
}
}
};
int main() {
ClockCache<int, std::string> cache(3);
cache.put(1, "one");
cache.put(2, "two");
cache.put(3, "three");
cache.get(1); // referenced = true
cache.put(4, "four"); // 2 또는 3 제거 (referenced = false)
return 0;
}성능 비교
알고리즘 비교
| 정책 | 무엇을 지우나 | 시간 복잡도 | 공간 복잡도 | 구현 난이도 |
|---|---|---|---|---|
| FIFO | 가장 먼저 들어온 것 | O(1) | O(n) | 낮음 |
| LRU | 가장 오래 안 쓴 것 | O(1) | O(n) | 중간 |
| LFU | 가장 적게 쓴 것 | O(1) ~ O(log n) | O(n) | 높음 |
| MRU | 가장 최근 쓴 것 | O(1) | O(n) | 중간 |
| Random | 아무거나 | O(1) | O(n) | 매우 낮음 |
| Clock | 참조 비트 기반 | O(1) ~ O(n) | O(n) | 중간 |
| OPT | 미래 안 쓰는 것 | 이론만 | - | 불가능 |
히트율 비교
테스트: 10,000번 접근, 캐시 크기 100
| 정책 | 히트율 | 특징 |
|---|---|---|
| OPT | 95% | 이론적 최적 |
| LRU | 85% | 시간 지역성 강함 |
| LFU | 80% | 빈도 기반 |
| FIFO | 70% | 단순 |
| Random | 60% | 무작위 |
| 결론: LRU가 범용적으로 우수 |
실무 사례
사례 1: Redis 캐시 정책
Redis eviction policies:
# redis.conf
maxmemory 100mb
maxmemory-policy allkeys-lru
# 정책 옵션:
# - noeviction: 제거 안함 (에러 반환)
# - allkeys-lru: 모든 키 중 LRU
# - volatile-lru: TTL 있는 키 중 LRU
# - allkeys-lfu: 모든 키 중 LFU
# - volatile-lfu: TTL 있는 키 중 LFU
# - allkeys-random: 무작위
# - volatile-random: TTL 있는 키 중 무작위
# - volatile-ttl: TTL 짧은 키 먼저C++ 클라이언트 예제:
#include <iostream>
#include <string>
// Redis 클라이언트 (hiredis 등)
void configureRedis() {
// redis.conf 설정
std::cout << "maxmemory 100mb" << std::endl;
std::cout << "maxmemory-policy allkeys-lru" << std::endl;
}
int main() {
configureRedis();
// 캐시 사용
// SET key1 value1
// GET key1
return 0;
}사례 2: OS 페이지 교체
Linux 페이지 교체: Clock 알고리즘 변형
#include <vector>
#include <iostream>
struct Page {
int page_number;
bool referenced;
};
class PageReplacementSimulator {
private:
size_t capacity_;
size_t hand_;
std::vector<Page> pages_;
public:
explicit PageReplacementSimulator(size_t capacity)
: capacity_(capacity), hand_(0) {}
void access(int page_number) {
for (auto& page : pages_) {
if (page.page_number == page_number) {
page.referenced = true;
std::cout << "Page " << page_number << " hit" << std::endl;
return;
}
}
std::cout << "Page " << page_number << " miss" << std::endl;
if (pages_.size() < capacity_) {
pages_.push_back({page_number, true});
} else {
evict_clock(page_number);
}
}
private:
void evict_clock(int page_number) {
while (true) {
if (!pages_[hand_].referenced) {
std::cout << "Evict page " << pages_[hand_].page_number << std::endl;
pages_[hand_] = {page_number, true};
hand_ = (hand_ + 1) % capacity_;
return;
}
pages_[hand_].referenced = false;
hand_ = (hand_ + 1) % capacity_;
}
}
};
int main() {
PageReplacementSimulator sim(3);
sim.access(1);
sim.access(2);
sim.access(3);
sim.access(1); // hit
sim.access(4); // miss, evict 2 or 3
return 0;
}사례 3: CDN 캐시 - LFU 변형
#include <unordered_map>
#include <map>
#include <list>
#include <iostream>
template <typename K, typename V>
class LFUCache {
private:
struct Node {
K key;
V value;
int freq;
};
size_t capacity_;
int min_freq_;
std::unordered_map<K, typename std::list<Node>::iterator> key_map_;
std::map<int, std::list<Node>> freq_map_;
public:
explicit LFUCache(size_t capacity) : capacity_(capacity), min_freq_(0) {}
std::optional<V> get(const K& key) {
auto it = key_map_.find(key);
if (it == key_map_.end()) return std::nullopt;
auto node_it = it->second;
int freq = node_it->freq;
Node node = *node_it;
freq_map_[freq].erase(node_it);
if (freq_map_[freq].empty()) {
freq_map_.erase(freq);
if (min_freq_ == freq) min_freq_++;
}
node.freq++;
freq_map_[node.freq].push_front(node);
key_map_[key] = freq_map_[node.freq].begin();
return node.value;
}
void put(const K& key, V value) {
if (capacity_ == 0) return;
auto it = key_map_.find(key);
if (it != key_map_.end()) {
auto node_it = it->second;
node_it->value = std::move(value);
get(key);
return;
}
if (key_map_.size() >= capacity_) {
auto& list = freq_map_[min_freq_];
K victim = list.back().key;
list.pop_back();
key_map_.erase(victim);
}
min_freq_ = 1;
freq_map_[1].push_front({key, std::move(value), 1});
key_map_[key] = freq_map_[1].begin();
}
};
int main() {
LFUCache<int, std::string> cache(3);
cache.put(1, "one");
cache.put(2, "two");
cache.put(3, "three");
cache.get(1);
cache.get(1); // freq = 2
cache.put(4, "four"); // 2 또는 3 제거 (freq = 1)
return 0;
}트러블슈팅
문제 1: FIFO의 Bélády 변칙
증상: 캐시 크기를 늘렸는데 히트율이 떨어짐
// 접근 패턴: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5
// 캐시 크기 3: 히트율 25%
// 캐시 크기 4: 히트율 10%
// ✅ LRU 사용
// 캐시 크기 3: 히트율 50%
// 캐시 크기 4: 히트율 60%문제 2: LFU의 “stale popular” 문제
증상: 예전에 많이 쓰였지만 지금은 안 쓰는 항목이 남음
// 접근 패턴:
// 1, 1, 1, 1, 1 (freq = 5)
// 2, 3, 4, 5, 6 (각 freq = 1)
// LFU: 1이 계속 남음 (지금은 안 쓰는데도)
// ✅ LFU with decay
// 시간마다 빈도 감쇠
freq = freq * 0.9문제 3: LRU의 순차 스캔 문제
증상: 순차 스캔 시 캐시 전체가 교체됨
// 접근 패턴: 1, 2, 3, ..., 1000 (순차)
// 캐시 크기: 100
// LRU: 히트율 0% (모든 페이지가 한 번씩만)
// ✅ MRU 또는 LRU-K
// MRU: 최근 것을 지움
// LRU-K: K번 참조된 것만 보호문제 4: 멀티스레드 경합
증상: 캐시 락 경합으로 성능 저하
// ❌ 단일 락
std::mutex cache_mutex;
LRUCache<int, std::string> cache(1000);
void access(int key) {
std::lock_guard<std::mutex> lock(cache_mutex); // 경합
cache.get(key);
}
// ✅ 샤딩
std::vector<LRUCache<int, std::string>> shards(16, LRUCache<int, std::string>(1000 / 16));
std::vector<std::mutex> shard_mutexes(16);
void access(int key) {
size_t shard_id = std::hash<int>{}(key) % 16;
std::lock_guard<std::mutex> lock(shard_mutexes[shard_id]);
shards[shard_id].get(key);
}마무리
캐시 교체 알고리즘은 워크로드에 따라 최적의 선택이 다릅니다.
핵심 요약
- FIFO
- 가장 먼저 들어온 것 제거
- 구현 단순, 히트율 낮음
- LRU
- 가장 오래 안 쓴 것 제거
- 범용적으로 우수
- LFU
- 가장 적게 쓴 것 제거
- 인기 항목 보호, 구현 복잡
- Clock
- 참조 비트 기반 LRU 근사
- OS 페이지 교체에 흔함
- Random
- 무작위 제거
- 락 경합 최소화
선택 가이드
| 워크로드 | 추천 정책 | 이유 |
|---|---|---|
| 범용 앱 캐시 | LRU | 시간 지역성 |
| 순차 스캔 | MRU | LRU 불리 |
| 인기 콘텐츠 보호 | LFU | 빈도 기반 |
| 단순 버퍼 | FIFO | 구현 단순 |
| 락 경합 최소화 | Random | 오버헤드 적음 |
| OS 페이지 | Clock | 하드웨어 지원 |
코드 예제 치트시트
// FIFO
std::queue<K> order;
std::unordered_map<K, V> map;
// LRU
std::list<std::pair<K, V>> list;
std::unordered_map<K, iterator> map;
// Clock
std::vector<Entry> entries;
size_t hand;
// Random
std::vector<K> keys;
std::unordered_map<K, V> map;
int victim = rand() % keys.size();다음 단계
- LRU 구현: C++ LRU 캐시 알고리즘 완벽 가이드
- 캐싱 전략: C++ 캐싱 전략
- map vs unordered_map: C++ map vs unordered_map
참고 자료
- “Operating System Concepts” - Silberschatz, Galvin, Gagne
- Redis Documentation: https://redis.io/docs/manual/eviction/
- LeetCode 146 (LRU Cache), 460 (LFU Cache) 한 줄 정리: 캐시 교체 알고리즘은 워크로드에 따라 FIFO·LRU·LFU·Clock 등을 선택하며, 범용적으로는 LRU가 시간 지역성에 강해 가장 많이 쓰인다.
심화 부록: 구현·운영 관점
이 부록은 앞선 본문에서 다룬 주제(「C++ 캐시 교체 알고리즘 총정리 | FIFO·LRU·LFU·Clock·MRU·OPT 완벽 비교」)를 구현·런타임·운영 관점에서 다시 압축합니다. 도메인별 세부 구현은 글마다 다르지만, 입력 검증 → 핵심 연산 → 부작용(I/O·네트워크·동시성) → 관측의 흐름으로 장애를 나누면 원인 추적이 빨라집니다.
내부 동작과 핵심 메커니즘
flowchart TD A[입력·요청·이벤트] --> B[파싱·검증·디코딩] B --> C[핵심 연산·상태 전이] C --> D[부작용: I/O·네트워크·동시성] D --> E[결과·관측·저장]
sequenceDiagram participant C as 클라이언트/호출자 participant B as 경계(런타임·게이트웨이·프로세스) participant D as 의존성(API·DB·큐·파일) C->>B: 요청/이벤트 B->>D: 조회·쓰기·RPC D-->>B: 지연·부분 실패·재시도 가능 B-->>C: 응답 또는 오류(코드·상관 ID)
- 불변 조건(Invariant): 버퍼 경계, 프로토콜 상태, 트랜잭션 격리, FD 상한 등 단계별로 문장으로 적어 두면 디버깅 비용이 줄어듭니다.
- 결정성: 순수 층과 시간·네트워크·스케줄에 의존하는 층을 분리해야 테스트와 장애 분석이 쉬워집니다.
- 경계 비용: 직렬화, 인코딩, syscall 횟수, 락 경합, 할당·GC, 캐시 미스를 의심 목록에 둡니다.
- 백프레셔: 생산자가 소비자보다 빠를 때 버퍼·큐·스트림에서 속도를 줄이는 신호를 어디에 둘지 정의합니다.
프로덕션 운영 패턴
| 영역 | 운영 관점 질문 |
|---|---|
| 관측성 | 요청 단위 상관 ID, 에러율·지연 p95/p99, 의존성 타임아웃·재시도가 대시보드에 보이는가 |
| 안전성 | 입력 검증·권한·비밀·감사 로그가 코드 경로마다 일관적인가 |
| 신뢰성 | 재시도는 멱등 연산에만 적용되는가, 서킷 브레이커·백오프·DLQ가 있는가 |
| 성능 | 캐시·배치 크기·커넥션 풀·인덱스·백프레셔가 데이터 규모에 맞는가 |
| 배포 | 롤백 룬북, 카나리/블루그린, 마이그레이션·피처 플래그가 문서화되어 있는가 |
| 용량 | 피크 트래픽·디스크·FD·스레드 풀 상한을 주기적으로 검증하는가 |
스테이징은 데이터 양·네트워크 RTT·동시성을 프로덕션에 가깝게 맞출수록 재현율이 올라갑니다.
확장 예시: 엔드투엔드 미니 시나리오
앞선 본문 주제(「C++ 캐시 교체 알고리즘 총정리 | FIFO·LRU·LFU·Clock·MRU·OPT 완벽 비교」)를 배포·운영 흐름에 맞춰 옮긴 체크리스트입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.
- 입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드를 경계에 둔다.
- 핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 로그·메트릭·트레이스에서 한 흐름으로 본다.
- 실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
- 호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지 확인한다.
- 부하 후 검증: 피크 대비 p95/p99, 에러율, 리소스 상한, 알림 임계값을 점검한다.
handle(request):
ctx = newCorrelationId()
validated = validateSchema(request)
authorize(validated, ctx)
result = domainCore(validated)
persistOrEmit(result, idempotentKey)
recordMetrics(ctx, latency, outcome)
return result문제 해결(Troubleshooting)
| 증상 | 가능 원인 | 조치 |
|---|---|---|
| 간헐적 실패 | 레이스, 타임아웃, 외부 의존성, DNS | 최소 재현 스크립트, 분산 트레이스·로그 상관관계, 재시도·서킷 설정 점검 |
| 성능 저하 | N+1, 동기 I/O, 락 경합, 과도한 직렬화, 캐시 미스 | 프로파일러·APM으로 핫스팟 확인 후 한 가지씩 제거 |
| 메모리 증가 | 캐시 무제한, 구독/리스너 누수, 대용량 버퍼, 커넥션 미반납 | 상한·TTL·힙/FD 스냅샷 비교 |
| 빌드·배포만 실패 | 환경 변수, 권한, 플랫폼 차이, lockfile | CI 로그와 로컬 diff, 런타임·이미지 버전 핀 |
| 설정 불일치 | 프로필·시크릿·기본값, 리전 | 스키마 검증된 설정 단일 소스와 배포 매트릭스 표준화 |
| 데이터 불일치 | 비멱등 재시도, 부분 쓰기, 캐시 무효화 누락 | 멱등 키·아웃박스·트랜잭션 경계 재검토 |
권장 순서: (1) 최소 재현 (2) 최근 변경 범위 축소 (3) 환경·의존성 차이 (4) 관측으로 가설 검증 (5) 수정 후 회귀·부하 테스트.
배포 전에는 git add → git commit → git push 후 npm run deploy 순서를 권장합니다.
자주 묻는 질문 (FAQ)
Q. 이 내용을 실무에서 언제 쓰나요?
A. LRU와 비슷한 캐시 교체 정책을 한 번에 정리합니다. FIFO·LFU·MRU·Random·Clock(Second Chance)·OPT의 직관·장단점·복잡도·실무 사용처, C++ 구현 예제, Redis·OS 페이지와… 실무에서는 위 본문의 예제와 선택 가이드를 참고해 적용하면 됩니다.
Q. 선행으로 읽으면 좋은 글은?
A. 각 글 하단의 이전 글 또는 관련 글 링크를 따라가면 순서대로 배울 수 있습니다. C++ 시리즈 목차에서 전체 흐름을 확인할 수 있습니다.
Q. 더 깊이 공부하려면?
A. cppreference와 해당 라이브러리 공식 문서를 참고하세요. 글 말미의 참고 자료 링크도 활용하면 좋습니다.
같이 보면 좋은 글 (내부 링크)
이 주제와 연결되는 다른 글입니다.
- C++ LRU 캐시 알고리즘 완벽 가이드 | Least Recently Used·O(1) 구현
- C++ Algorithm Replace | ‘치환 알고리즘’ 가이드
- 알고리즘 BFS vs DFS 완벽 비교 | 그래프 탐색 선택 가이드
이 글에서 다루는 키워드 (관련 검색어)
C++, LRU, LFU, FIFO, 캐시, 알고리즘, Clock 등으로 검색하시면 이 글이 도움이 됩니다.