Tagged articles
Lazy Free
14 articles · Page 1 of 1
This article explains why oversized Redis keys (BigKeys) cause data skew, network blockage, slow queries, and high CPU load, shows how to detect them with redis-cli and other tools, and provides practical strategies—including lazy deletion, key splitting, and preventive design—to mitigate their impact on production systems.
BigKeyLazy Freekey management
0 likes · 22 min read

This article explains Redis's original single‑threaded event‑driven design, the problems it causes, how the Lazy Free mechanism and asynchronous deletion were introduced in Redis 4.0, and how Redis 6.0 adds multi‑threaded I/O while discussing its limitations and comparing it with Tair's approach.
Database ArchitectureLazy FreeMulti-threaded I/O
0 likes · 16 min read

This article explains Redis’s original single‑threaded event‑driven architecture, its performance bottlenecks, and how versions 4.0 and 6.0 introduced Lazy Free and multithreaded I/O mechanisms—including asynchronous key deletion, background freeing, and I/O thread pools—to improve scalability while outlining their implementation details, limitations, and comparisons with Tair.
Database InternalsLazy FreeMultithreaded I/O
0 likes · 15 min read

The article explains how Redis, originally a single‑threaded in‑memory cache, introduces Lazy Free in version 4.0 and multi‑threaded I/O in version 6.0 to mitigate blocking during large key deletions, describes the underlying event‑driven architecture, shows relevant source code, and discusses the benefits and constraints of these mechanisms.
Lazy FreeMultithreaded I/Oevent-loop
0 likes · 16 min read

This article explains how Redis, originally a single‑threaded in‑memory cache, introduced Lazy Free and multi‑threaded I/O to eliminate blocking during large key deletions, improve QPS, and lay the groundwork for future multithreading strategies.
Database PerformanceLazy FreeMultithreaded I/O
0 likes · 16 min read

This article explains how Redis, originally a single‑threaded in‑memory cache, introduced Lazy Free in version 4.0 and multi‑threaded I/O in version 6.0 to mitigate blocking deletions and improve I/O throughput, detailing the underlying event model, code implementations, performance trade‑offs, and comparisons with Tair's threading design.
Database PerformanceLazy FreeMultithreaded I/O
0 likes · 16 min read

Redis, traditionally a single‑threaded in‑memory cache, introduces Lazy Free in version 4.0 and multi‑threaded I/O in version 6.0 to mitigate blocking during large key deletions and improve performance, with detailed explanations of event handling, code implementations, limitations, and comparisons to Tair’s threading model.
I/O ThreadLazy FreeMultithreading
0 likes · 16 min read

This article explains Redis's original single‑threaded event loop, the performance problems it causes, and how Redis 4.0 introduced Lazy Free and Redis 6.0 added multithreaded I/O, comparing the implementation with Tair's more elegant multithreaded design.
ConcurrencyDatabase InternalsLazy Free
0 likes · 16 min read

This article explains Redis's original single‑threaded event model, the performance bottlenecks it creates, and how Redis 4.0 introduced Lazy Free for asynchronous large‑key deletion while Redis 6.0 added multi‑threaded I/O to improve read/write throughput, including implementation details and limitations.
Lazy FreeMultithreaded I/O
0 likes · 17 min read

The article explains how Redis evolves from a single‑threaded in‑memory cache to using Lazy Free and multi‑threaded I/O to alleviate blocking on large key deletions, describing the underlying event model, code implementations, performance trade‑offs, and comparisons with Tair's threading approach.
ConcurrencyDatabase PerformanceLazy Free
0 likes · 16 min read

This article explains how Redis evolves from a single‑threaded event‑driven cache to using Lazy Free for asynchronous key deletion and multi‑threaded I/O for improved performance, detailing the underlying mechanisms, code implementations, limitations, and comparisons with Tair's threading model.
Database PerformanceLazy FreeMultithreaded I/O
0 likes · 16 min read

Learn how to dramatically boost Redis speed by shortening key/value sizes, enabling lazy free, setting expirations, disabling costly commands, using slowlog, pipelines, avoiding mass expirations, optimizing clients, limiting memory, running on physical servers, tweaking persistence, disabling THP, and adopting distributed architectures.
CachingLazy FreePipeline
0 likes · 19 min read

Learn how to dramatically improve Redis performance by shortening key-value sizes, enabling lazy free, setting expirations, disabling costly commands, using slowlog, leveraging pipeline, preventing mass expirations, optimizing client connections, limiting memory, running on physical servers, configuring persistence, disabling THP, and adopting distributed architectures.
Lazy FreePipelinedatabase tuning
0 likes · 18 min read

This article explains how Redis removes expired keys using periodic and lazy deletion, describes the slave expiration handling, details the asynchronous memory reclamation commands like UNLINK and FLUSHALL ASYNC, and outlines the various maxmemory eviction policies including LRU, LFU, and their implementations.
CacheLFULRU
0 likes · 13 min read
