Tagged articles
Cache Eviction
48 articles · Page 1 of 1
This article explores Caffeine's W-TinyLFU eviction algorithm, five-step hit-rate engineering methodology, and a real-world Spring Boot case study that improved cache hit rate from 62% to 98.7% through capacity weighting, refresh-after-write, and hot-key isolation.
AsyncCacheCache EvictionCache Hit Rate
0 likes · 19 min read

This article explains how LRU cache combines a hash map for O(1) key lookup with a doubly linked list to maintain access order, enabling O(1) get and put operations including eviction of least recently used items, illustrated with step-by-step examples and a complete Python implementation.
AlgorithmCache EvictionLRU cache
0 likes · 11 min read

Salesforce AI Research and UIUC propose Random Attention, a simple KV cache eviction method that randomly retains reasoning tokens while protecting the prompt, matching state-of-the-art baselines across math, science, and code reasoning tasks and improving inference throughput by 32–43% in vLLM serving.
Cache EvictionKV CacheLLM inference
0 likes · 20 min read

This article presents fourteen practical scenarios covering the design, pitfalls, strategies, and implementation details of distributed caching in Spring Boot, including cache breakdown prevention, write‑through vs. write‑behind, eviction policies, negative caching, secondary caches, cache‑aside pattern, warming, monitoring, consistency, and custom key generation, all illustrated with concrete code examples.
Cache ConsistencyCache EvictionDistributed Caching
0 likes · 17 min read

A joint effort by Baidu Baige and Fudan University introduces the LU‑KV framework, which treats KV‑cache budget allocation as a global combinatorial optimization problem, achieving only 0.52% relative performance loss at 80% compression and establishing a new efficiency‑accuracy SOTA on LongBench.
Cache EvictionEfficiencyICML 2026
0 likes · 5 min read

SpringBoot developers can dramatically boost throughput and cut latency by pairing a microsecond‑level local cache (Caffeine or Guava) with Redis, using a two‑level architecture that isolates hot data in JVM memory, reduces network and serialization overhead, and provides configurable eviction policies for various use cases.
Cache EvictionCaffeineGuava
0 likes · 13 min read

This article explains why LRU needs a doubly linked list, how to achieve O(1) LFU with two hash maps and a minFreq pointer, and why Redis uses approximate LRU and an 8‑bit Morris counter for LFU, providing full Java, Go, and Python implementations.
Cache EvictionGoJava
0 likes · 5 min read

This article explains Redis eviction policies, how the eviction process works, and practical solutions for cache penetration, breakdown, and avalanche, helping you select optimal strategies and mitigate high‑traffic cache failures.
BackendCache EvictionRedis
0 likes · 10 min read

This article explains Redis cache eviction policies—including noeviction, allkeys‑lru, volatile‑lru, random, ttl, and lfu—detailing when to use each, how the eviction process works, and practical solutions for cache penetration, breakdown, and avalanche to keep your backend stable under high load.
BackendCache EvictionRedis
0 likes · 11 min read

Explore Redis cache eviction policies, understand how strategies like allkeys‑lru, volatile‑ttl, and noeviction work, and learn practical solutions for cache penetration, breakdown, and avalanche—including Bloom filters, mutex locks, and staggered expirations—to keep your backend resilient under high load.
BackendCache EvictionRedis
0 likes · 10 min read

Redis implements an approximate LRU using random sampling and timestamps, while classic LRU relies on exact access order; the article explains both LRU and LFU fundamentals, their Java implementations, Redis-specific variants, trade‑offs, use‑case recommendations, and configuration tips for selecting the optimal eviction policy.
Cache EvictionJavaLFU
0 likes · 21 min read

This article explains Redis eviction policies, how the eviction process works, and practical solutions for cache penetration, breakdown, and avalanche, helping developers choose the right strategy and optimize cache performance under high load.
BackendCache Evictioncache penetration
0 likes · 10 min read

Redis achieves millisecond‑level latency by storing all data in memory, using specially optimized data structures such as SDS, incremental‑rehash hash tables, and ziplists, employing a single‑threaded event‑driven model with epoll‑based I/O multiplexing, and streamlining network communication through the compact RESP protocol, compression, and batching, while also offering flexible eviction and persistence strategies.
Cache EvictionI/O multiplexingRedis
0 likes · 11 min read

This article provides a comprehensive guide to backend caching, covering fundamental concepts, usage scenarios, read‑through and cache‑aside strategies, local and distributed cache types, popular services like Redis and Memcached, eviction algorithms such as FIFO, LRU, LFU, and common issues like consistency, avalanche, penetration, and stampede, along with practical mitigation techniques.
Cache EvictionCache strategiesCaching
0 likes · 14 min read

This article explores common caching scenarios, selection criteria, and best‑practice pitfalls, demonstrates a Go demo with configurable cache modes, compares byte‑versus‑struct caches, discusses concurrency, expiration, failover, cache transfer, lock contention, memory management, and provides benchmark results to guide high‑performance backend development.
Cache EvictionCachingGo
0 likes · 23 min read

Redis serves as a powerful in‑memory key‑value store for distributed caching, offering various data structures, persistence options, deployment modes, eviction policies, and update strategies, while addressing consistency challenges, cache miss scenarios, and failure modes such as penetration, breakdown, and avalanche.
Cache ConsistencyCache EvictionRedis
0 likes · 13 min read

This article explains how to implement an O(1) LRU cache in Go by combining a hash table with a doubly linked list, detailing the put and get operations, eviction policy, and providing complete, ready‑to‑run source code along with illustrative diagrams.
Cache EvictionGoLRU cache
0 likes · 4 min read

This article explains Redis's LFU eviction algorithm, its implementation details, code-level mechanics, configuration steps, and how it improves upon LRU by using frequency-based counters and decay to make smarter cache eviction decisions.
AlgorithmCache EvictionLFU
0 likes · 12 min read

This article explains the principles, implementation details, and trade‑offs of Redis’s LRU and LFU cache eviction algorithms, including their data structures, code snippets, configuration parameters, and practical guidance on choosing the appropriate strategy based on workload characteristics.
Cache EvictionLFULRU
0 likes · 13 min read

Redis implements approximate LRU and LFU eviction policies by sampling keys and using a compact 24‑bit field to store timestamps and counters, where LRU evicts the least recently accessed items and LFU evicts those with low, decay‑adjusted access frequency, each with trade‑offs for different workloads.
AlgorithmCache EvictionLFU
0 likes · 13 min read

This article examines the storage bottlenecks in large‑scale AI training, evaluates local‑disk and Alluxio‑based distributed caching strategies, proposes uniform cache eviction and replica‑aware global policies, and introduces the SiloD framework for coordinated compute‑storage scheduling to dramatically improve GPU utilization and overall cluster throughput.
AI TrainingAlluxioCache Eviction
0 likes · 16 min read

This article explains Redis eviction policies, compares strategies like allkeys‑lru, volatile‑ttl, and noeviction, and provides practical solutions for cache penetration, breakdown, and avalanche to maintain system stability under high concurrency.
BackendCache Evictioncache penetration
0 likes · 11 min read

This article explains Redis eviction policies such as allkeys‑lru, volatile‑ttl, and others, discusses how the eviction process works, and provides practical solutions for cache penetration, breakdown (stampede), and avalanche, including Bloom filters, mutex locks, and randomized TTLs.
BackendCache EvictionRedis
0 likes · 10 min read

The article analyzes a weekend outage of a Spring Boot microservice where all HTTP requests timed out, tracing the root cause to Caffeine's synchronous cache eviction lock being blocked by a long‑running compute operation, and proposes using AsyncCache with a dedicated thread pool to avoid similar contention.
Cache EvictionCaffeineJFR
0 likes · 11 min read

The article explains the benefits, costs, and various update, penetration, no‑hole, avalanche, and hot‑key optimization techniques for caching in high‑concurrency distributed systems, providing practical guidance on choosing appropriate strategies based on consistency requirements and system load.
Cache EvictionCachingcache penetration
0 likes · 16 min read

This article explains the advantages of Caffeine Cache's W‑TinyLFU algorithm over traditional FIFO, LRU, and LFU policies, details its eviction and reference‑type strategies, and provides step‑by‑step guidance for integrating Caffeine into Spring Boot applications with code examples and configuration tips.
Cache EvictionCaffeine CacheJava
0 likes · 27 min read

This article explains the high‑performance Caffeine Cache library, its W‑TinyLFU eviction algorithm, various loading and eviction strategies, statistics collection, and how to integrate and configure it in Spring Boot using annotations and programmatic beans.
Cache AnnotationsCache EvictionCaffeine Cache
0 likes · 22 min read

This article provides an in‑depth overview of caching, covering its definition, when to use it, core concepts, various cache types (client, server, CDN, reverse‑proxy, in‑process, distributed), eviction policies, multi‑level cache architectures, common pitfalls such as cache avalanche, penetration and breakdown, and practical mitigation techniques.
BackendCache EvictionCaching
0 likes · 30 min read

This article explains Redis memory eviction strategies, including volatile and allkeys policies, details the approximate LRU algorithm Redis uses, and provides Java implementations of an LRU cache using LinkedHashMap and a custom doubly‑linked list, complete with code examples and configuration settings.
Cache EvictionJavaLRU
0 likes · 7 min read

The article explains why caching is essential for high‑concurrency distributed systems, analyzes its benefits and costs, and then details various cache‑update, penetration‑prevention, bottom‑hole, avalanche, and hot‑key‑rebuild optimization techniques, offering practical guidance for reliable and performant backend architectures.
Bloom FilterCache EvictionRedis
0 likes · 15 min read

This article examines the role of caching in high‑concurrency distributed systems, outlining its benefits and costs, various update policies such as LRU/LFU/FIFO, timeout eviction, active refresh, and advanced techniques like cache penetration protection, no‑hole, avalanche, and hot‑key mitigation.
Cache EvictionCachingcache penetration
0 likes · 15 min read

This article explains the role of caching in high‑concurrency distributed systems, detailing its benefits, costs, various update strategies, and advanced optimizations such as penetration protection, bottom‑hole mitigation, avalanche prevention, and hot‑key rebuild handling.
Cache EvictionHot Keycache avalanche
0 likes · 15 min read

This article explains the benefits, costs, and various update, penetration, bottom‑hole, avalanche, and hot‑key rebuilding strategies for caches in high‑concurrency distributed systems, offering practical guidance on choosing eviction algorithms, using Bloom filters, and improving overall system performance and reliability.
Bloom FilterCache EvictionCaching
0 likes · 13 min read

This article explains the benefits, costs, and various update, penetration, hole, avalanche, and hot‑key optimization techniques for caches in high‑concurrency distributed systems, providing practical guidance on choosing appropriate strategies such as LRU/LFU/FIFO, timeout eviction, proactive updates, Bloom filters, and concurrency‑aware batch operations.
Cache EvictionCachingRedis
0 likes · 15 min read

The article discusses the importance of caching in high‑concurrency distributed systems, outlining its benefits and costs, various update policies such as LRU/LFU/FIFO, expiration, active refresh, and advanced optimizations like penetration protection, hole mitigation, avalanche prevention, and hot‑key rebuild techniques.
Cache EvictionCachingcache avalanche
0 likes · 14 min read

The article explains why caching is essential in high‑concurrency distributed systems, analyzes its benefits and costs, and then details various cache update, penetration, no‑hole, avalanche, and hot‑key rebuilding techniques, offering practical guidance for backend engineers.
Cache Evictionbackend optimizationcache avalanche
0 likes · 14 min read

This article examines the role of caching in high‑concurrency distributed systems, outlining its performance benefits and associated costs, and detailing various cache‑update strategies—including LRU/LFU/FIFO, expiration, active refresh, Bloom‑filter protection, and solutions for penetration, avalanche, hot‑key rebuild, and the “no‑bottom‑hole” problem.
Bloom FilterCache EvictionCaching
0 likes · 15 min read

With hardware costs dropping, many default to Redis for caching, but it isn’t always optimal; this article examines EhCache—a pure‑Java, in‑process cache—covering its architecture, eviction policies, API and XML configurations, and step‑by‑step Spring Boot integration, helping you decide when to prefer it.
BackendCache EvictionCaching
0 likes · 15 min read

Explore comprehensive caching concepts—including client, server, and CDN caches—along with hit rate metrics, eviction methods, popular strategies like FIFO, LRU, LFU, and design patterns such as Cache‑Aside, Read/Write‑Through, and Write‑Behind, plus essential testing considerations for robust application performance.
Backend PerformanceCache EvictionCache Hit Rate
0 likes · 8 min read

This article introduces Caffeine Cache as a high‑performance local caching solution that improves on Guava Cache by using the W‑TinyLFU eviction algorithm, explains its core concepts, demonstrates manual, synchronous, and asynchronous loading strategies, details eviction policies, and provides step‑by‑step integration and configuration examples for Spring Boot applications.
Cache EvictionCaffeine CacheJava Caching
0 likes · 22 min read

Understanding Caffeine Cache in Java involves using its builder for options like expiration, refresh, and weight‑based eviction, recognizing that configuring both expireAfterWrite and expireAfterAccess is redundant, grasping core methods such as isBounded, refreshes, computeIfAbsent, and avoiding common pitfalls like mis‑ordered expiration settings, blocking loaders, cache penetration, and mutable cached objects.
Cache EvictionCaffeine CacheJava
0 likes · 15 min read

This article explains why technical interviews focus on problem‑solving skills, outlines a four‑step interview approach, introduces the LRU cache eviction policy, analyzes required operations, selects HashMap plus a doubly linked list as the optimal data structures, and provides a complete Java implementation with detailed commentary.
Cache EvictionHashMapInterview
0 likes · 15 min read

This article explains cache fundamentals—from CPU and local caches to distributed systems—covers design principles, performance‑affecting factors, eviction algorithms, and common high‑concurrency issues such as penetration, stampede, and avalanche, and provides practical solutions for selecting and optimizing cache strategies.
CPU cacheCache EvictionCaching
0 likes · 16 min read

This article traces iQIYI’s five‑stage Java caching journey—from early database lookups, through Redis synchronization, in‑process HashMap and Guava caches, to modern Caffeine with W‑TinyLFU—explaining each phase’s advantages, drawbacks, eviction algorithms, and implementation details such as segment locking, expiration queues, and multi‑queue data structures.
Cache EvictionCaffeineGuava
0 likes · 21 min read

This article explains why cache design is essential for high‑concurrency systems, compares CPU and application caches, outlines multi‑level and distributed caching strategies, discusses write‑through/write‑behind patterns, cache synchronization methods, penetration protection, and eviction policies to alleviate database pressure.
Cache Evictiondistributed cachehigh concurrency
0 likes · 12 min read


JD TechJul 26, 2018 · Backend Development
This article explains the motivation behind cache design, compares CPU and application‑level caches, discusses multi‑level and distributed caching, outlines synchronization methods, eviction policies, and answers frequent cache‑related questions to help reduce database load and improve system performance.
Backend PerformanceCache EvictionCaching
0 likes · 13 min read

This article explains various cache eviction strategies, compares heap, off‑heap, disk and distributed cache types, and provides concrete Java implementations using Guava Cache, EhCache 3.x and MapDB with code examples and usage patterns such as Cache‑Aside and Cache‑As‑SoR.
CacheCache EvictionEhcache
0 likes · 18 min read


ITPUBJan 21, 2017 · Databases
This article explains Redis's LRU eviction mechanism, starting with a brief LRU overview, presenting a Python LRU cache implementation, then detailing Redis's internal LRU clock, object fields, maxmemory policies, and both active and passive eviction processes, highlighting configuration impacts on performance.
Cache EvictionLRUPython
0 likes · 15 min read
