Tagged articles
eviction
33 articles · Page 1 of 1
This guide details diagnosing and resolving Kubernetes node DiskPressure alerts by analyzing filesystem signals (nodefs, imagefs, containerfs), eviction mechanisms, image garbage collection, log rotation, ephemeral storage limits, kubelet configuration, monitoring strategies, and recovery procedures with practical commands for containerd/CRI-O environments.
ContainerdDiskPressureKubernetes
0 likes · 30 min read

This article explains how Kubernetes requests and limits act as a contract between workloads and the scheduler, detailing their distinct roles, the divergent consequences of CPU throttling versus memory OOMKills, the three QoS classes that determine eviction priority, and how LimitRange and ResourceQuota enforce resource policies at the namespace level.
CPU throttlingKubernetesLimitRange
0 likes · 10 min read

This article explains why naive cache eviction fails, why LRU is the go‑to strategy for many Go projects, and provides a production‑ready LRU implementation with detailed code, lock‑granularity tips, key design considerations, and scenarios where LRU is not suitable.
CacheGoLRU
0 likes · 9 min read

This article walks through a production incident where Redis began returning missing keys, detailing the step‑by‑step diagnosis—from monitoring logs and TTL checks to discovering memory spikes caused by client‑output‑buffer‑limit overflow and pipeline traffic—followed by emergency and permanent remediation measures.
MemoryPipelineclient-output-buffer-limit
0 likes · 11 min read

This article explains why caching is a performance trade‑off, outlines essential cache features such as size limits, eviction policies, TTL, configuration, integration APIs, and distributed versus local modes, and provides a comprehensive checklist for evaluating cache providers.
CacheJCacheSpring Cache
0 likes · 12 min read

A Redis instance suddenly reported 78.9 GB of used_memory against a 16 GB maxmemory limit, triggering massive key eviction; this article explains how INFO reports used_memory, what the metric actually measures, how Redis 7 changes memory accounting, the exact eviction conditions, and provides a Python script to pinpoint the memory‑hogs.
PythonRediseviction
0 likes · 17 min read

This article explains the inner workings of Caffeine's cache, covering the getIfPresent method, the design of ReadBuffer and StripedBuffer, eviction policies, the maintenance cycle, and the climb algorithm that dynamically adjusts window and protected partitions for optimal performance.
BufferCacheCaffeine
0 likes · 31 min read

This article explains the inner workings of Caffeine's getIfPresent method, the design of its MPSC ReadBuffer and WriteBuffer, the maintenance cycle, eviction strategies, and the TinyLFU algorithm, providing Java code examples and diagrams to illustrate how caching decisions are made in high‑concurrency environments.
CaffeineConcurrencyJava
0 likes · 31 min read


JD TechFeb 19, 2025 · Backend Development
This article provides a comprehensive walkthrough of Caffeine cache's architecture, explaining its fixed-size eviction policy, underlying data structures such as ConcurrentHashMap, MPSC buffers, Count‑Min Sketch frequency tracking, and the dynamic window‑probation‑protected zones, while detailing key methods like put, getIfPresent, and maintenance.
CacheCaffeineConcurrency
0 likes · 71 min read

This guide introduces Caffeine, a high‑performance Java caching library, explains its core features, configuration options, loading strategies—including manual, automatic, asynchronous, and async loading caches—eviction policies, removal listeners, and statistics collection, providing code examples for each use case.
CaffeineJavaeviction
0 likes · 16 min read

This article introduces the high‑performance Caffeine caching library for Spring Boot 3.2, explains its core features, demonstrates detailed performance benchmarks, and provides practical code examples covering synchronous and asynchronous operations, eviction policies, removal listeners, refresh mechanisms, and statistics collection.
AsyncCacheCaffeine
0 likes · 12 min read

This article explains how Redis handles memory exhaustion by configuring maxmemory and maxmemory-policy, detailing each eviction strategy (noeviction, volatile‑lru, volatile‑lfu, volatile‑ttl, volatile‑random, allkeys‑lru, allkeys‑lfu, allkeys‑random), their implementation details, and the underlying approximate LRU algorithm.
LFULRURedis
0 likes · 8 min read

This article introduces the Java Caffeine caching library, explains its manual, loading, and async cache APIs, details eviction and refresh strategies, shows how to collect statistics, and demonstrates full integration with Spring Boot using Maven dependencies, cache annotations, constant definitions, configuration classes, and usage examples.
BackendCacheCaffeine
0 likes · 16 min read

This article explains why a Kubernetes pod can be OOMKilled and repeatedly restarted even before reaching its memory limit, detailing the role of QoS classes, oom_score calculations, and node‑memory pressure in the eviction process, and offers practical mitigation steps.
OOMKillPodQoS
0 likes · 10 min read

This article explains how to size Redis memory, configure maxmemory and maxmemory‑policy settings, and choose among various eviction strategies—including no‑eviction, allkeys‑lru, allkeys‑lfu, and volatile options—while detailing the underlying LRU and LFU algorithms used by Redis.
BackendLFUMemory
0 likes · 7 min read

This article explains Redis's in‑memory database architecture, detailing data locality, various eviction policies such as LRU, LFU, random and TTL, their configuration via maxmemory settings, and provides code examples of the eviction process and memory‑freeing functions.
LFULRURedis
0 likes · 17 min read

This article explains the Kubernetes pod lifecycle, the meaning of the Terminating state, detailed pod creation and deletion processes, and the eviction mechanisms of both kube‑controller‑manager and kubelet, offering troubleshooting steps and best practices to resolve pods that remain stuck in Terminating.
Cluster OperationsKubernetesPod Lifecycle
0 likes · 13 min read

This article explains how Redis handles memory exhaustion by setting key expirations with commands like expire and pexpire, describes its lazy and periodic expiration strategies, details the eight configurable eviction policies, and dives into the internal LRU and LFU algorithms used for key eviction.
LFULRURedis
0 likes · 12 min read


ITPUBApr 15, 2021 · Databases
This article explains how to set Redis's maximum memory usage via configuration files or runtime commands, details all built‑in eviction policies, demonstrates retrieving and changing these policies, and dives into the LRU and LFU algorithms—including Java sample code and Redis's approximate LRU implementation.
LFULRURedis
0 likes · 11 min read

This article explains how to configure Redis's maximum memory, describes the various eviction policies—including noeviction, allkeys‑lru, volatile‑lru, random and ttl strategies—covers how to query and set these policies, and details the LRU and LFU algorithms used by Redis for cache management.
LFULRUMemory
0 likes · 9 min read

This article explains how Redis handles key expiration, the commands for setting TTL, the three expiration strategies, the eight memory‑eviction policies, and the internal LRU and LFU algorithms used to manage hot data when memory is exhausted.
LFULRUeviction
0 likes · 12 min read

This article explains how Redis handles memory exhaustion by setting key expirations, describes the four expiration commands, details the three expiration strategies, outlines the eight eviction policies, and dives into the inner workings of Redis's LRU and LFU algorithms with configuration examples.
LFULRURedis
0 likes · 13 min read

This article explains the typical reasons behind Redis latency spikes—such as complex commands, big keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network overload—and provides practical steps and monitoring techniques to identify and resolve each problem.
BigKeyPerformance TuningRedis
0 likes · 18 min read

This article explains how Redis, created to alleviate MySQL’s read‑heavy load, provides in‑memory caching, various data structures, expiration policies, eviction strategies, Bloom‑filter protection against cache penetration, and techniques to prevent cache breakdown and avalanche, improving overall system performance.
Bloom FilterRediseviction
0 likes · 10 min read

This article outlines the essential design considerations for building a local cache in Java, covering data structures, capacity limits, eviction policies, expiration handling, thread safety, blocking mechanisms, simple APIs, and optional persistence, with illustrative code examples.
ConcurrencyJavaeviction
0 likes · 13 min read

The article explains Alluxio's tiered metadata management architecture, describing how the system separates hot and cold metadata into cached and persisted layers, and details the custom asynchronous eviction thread and cache implementation that replace Guava cache for efficient large‑scale metadata handling.
AlluxioCachedistributed storage
0 likes · 15 min read

This article explains how Redis handles memory limits with the maxmemory setting, describes the six eviction policies—including noeviction, allkeys‑lru, volatile‑lru, allkeys‑random, volatile‑random, and volatile‑ttl—covers the LRU and LFU algorithms, and outlines the three key expiration deletion methods as well as RDB and AOF persistence handling.
CachingLFULRU
0 likes · 11 min read

This article outlines the essential considerations for designing a local cache—including data structures, size limits, eviction policies, expiration, thread safety, blocking mechanisms, simple APIs, and persistence—and demonstrates implementation approaches with Java code examples such as Map usage, synchronized caches, and memoization techniques.
Javaevictionlocal cache
0 likes · 11 min read

Redis employs distinct memory reclamation mechanisms—expiration policies (timed, lazy, periodic) and eviction strategies triggered when maxmemory is reached—each with trade-offs in CPU and memory usage, and offers configurable policies such as allkeys‑lru, volatile‑ttl, and noeviction to manage cache data effectively.
CachingRediseviction
0 likes · 6 min read

This article outlines the essential design points for a local Java cache—including data structures, size limits, eviction policies, expiration handling, thread safety, blocking mechanisms, simple APIs, and persistence options—while providing concrete code examples and implementation guidance.
CacheConcurrencyJava
0 likes · 12 min read

Redis provides a configurable maxmemory setting to limit memory usage, and offers several eviction policies—including allkeys‑lru, volatile‑lru, and random strategies—implemented via an approximate LRU algorithm whose behavior can be tuned with maxmemory‑samples, allowing administrators to balance performance and memory reclamation.
LRURediseviction
0 likes · 11 min read

The article reviews three cache update strategies—algorithmic eviction (LRU/LFU/FIFO), timeout‑based eviction, and proactive updates—analyzing their consistency guarantees and maintenance costs, and then proposes a combined best‑practice approach for reliable backend caching.
BackendLRUTimeout
0 likes · 7 min read

This article examines how popular caching systems such as Redis, Memcached, Guava Cache, and Ehcache implement eviction policies like LRU, LFU, and FIFO, comparing their algorithmic approaches, code implementations, and expiration handling mechanisms.
CacheEhcacheGuava
0 likes · 7 min read
