Kebijakan Penghapusan Cache
Jelajahi cara cache menentukan apa yang dipertahankan dan dibuang saat memori penuh, termasuk LRU, LFU, FIFO, TTL, serta komprominya.
Kebijakan Penghapusan Cache adalah pelajaran System Design Basics for Backend Developers gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar System Design Basics for Backend Developers, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus System Design Basics for Backend Developers mencakup 4 pelajaran total.
Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.
Why Eviction Is Necessary
A cache is fast because it lives in limited memory. When it fills up, it must evict something to make room for new data. The eviction policy decides what to drop.
A good policy keeps the data most likely to be reused.
Hit Rate Is the Goal
The metric that matters is the hit rate: the fraction of requests served from cache. A better eviction policy raises the hit rate, which means fewer slow trips to the database or origin.
hits = 850
misses = 150
hit_rate = hits / (hits + misses)
print('hit rate:', hit_rate)FIFO
FIFO (First In, First Out) evicts the oldest inserted item regardless of usage. It is simple but ignores access patterns, so a frequently used old item can be wrongly evicted.
LRU: Least Recently Used
LRU evicts the item that has not been accessed for the longest time. It assumes recently used data will be used again soon — true for most workloads, which is why LRU is the default in many caches.
Implementing LRU
A classic LRU uses an ordered map. On access, move the key to the most-recent end; when full, evict from the least-recent end.
from collections import OrderedDict
class LRU:
def __init__(self, cap):
self.cap = cap
self.d = OrderedDict()
def get(self, k):
if k in self.d:
self.d.move_to_end(k)
return self.d[k]
def put(self, k, v):
self.d[k] = v
self.d.move_to_end(k)
if len(self.d) > self.cap:
self.d.popitem(last=False)
c = LRU(2)
c.put('a', 1); c.put('b', 2); c.get('a'); c.put('c', 3)
print(list(c.d.keys()))LFU: Least Frequently Used
LFU evicts the item accessed the fewest times. It favors long-term popular items over recent bursts. The downside: a once-popular item can linger long after it stops being useful.
TTL-Based Expiration
A TTL (time to live) expires items after a fixed duration regardless of memory pressure. It bounds staleness and is often combined with LRU: TTL controls freshness, LRU controls memory.
SET session:42 "..." EX 3600
# expires in 3600 secondsRandom and Allkeys Variants
Some caches offer random eviction (cheap, surprisingly decent) and scope variants: evict only keys with a TTL set, or evict from all keys. Redis exposes policies like allkeys-lru and volatile-ttl.
Thundering Herd on Eviction
When a hot key is evicted or expires, many clients may simultaneously rebuild it — a thundering herd that hammers the origin. Mitigate with request coalescing (single-flight) or slightly randomized TTLs to spread out expirations.
Choosing a Policy
Match the policy to the workload:
- Recency-driven traffic: LRU
- Stable popularity: LFU
- Freshness-critical data: TTL
- Uniform access: random is fine and cheap
Eviction in a CDN
CDNs apply the same ideas at the edge. Each edge node has finite storage and evicts (often LRU) plus honors Cache-Control: max-age as a TTL. Understanding eviction explains why a cold edge node has a low initial hit rate.
Quick Check
Test your understanding of eviction policies.
Recap
You learned how caches manage limited memory:
- Eviction policies aim to maximize hit rate
- FIFO, LRU, LFU, TTL, and random each suit different patterns
- Thundering herds need coalescing or jittered TTLs
- CDNs apply the same eviction logic at the edge
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Kebijakan Penghapusan Cache” gratis?
Ya — teks lengkap “Kebijakan Penghapusan Cache” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus System Design Basics for Backend Developers, upgrade ke CoddyKit PRO. Kursus System Design Basics for Backend Developers mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Kebijakan Penghapusan Cache”?
Jelajahi cara cache menentukan apa yang dipertahankan dan dibuang saat memori penuh, termasuk LRU, LFU, FIFO, TTL, serta komprominya. Kamu berlatih System Design Basics for Backend Developers dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai System Design Basics for Backend Developers?
Tidak diperlukan pengalaman sebelumnya. System Design Basics for Backend Developers di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.
Berapa lama pelajaran “Kebijakan Penghapusan Cache” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran System Design Basics for Backend Developers ini?
Ya. Setiap pelajaran System Design Basics for Backend Developers menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Pola Invalidasi Tembolok
- Integrasi CDN dan Tembolok Tepi
- Tembolok Terdistribusi dengan Redis
- Kebijakan Penghapusan Cache