1 views collected around this technical thread.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.