This article explains how a company extended native Redis to support bidirectional synchronization across multiple data‑center sites, addressing issues such as lack of master‑master replication, data loops, idempotency, write conflicts, and providing a custom rLog design for efficient breakpoint‑resume and performance.
This article examines the challenges of caching low‑frequency static data in microservice systems and proposes a comprehensive solution that combines business services, Redis, persistent queues, and consistency‑checking programs to achieve high‑performance, near‑real‑time data access while mitigating cache‑related risks.
After a week of intermittent API hangs in an internal sandbox, we traced the issue to Redis connection pool blocking caused by missing max‑wait configuration, leading to threads waiting indefinitely; by adjusting Jedis pool settings, using proper connection release, and avoiding unsupported commands, the deadlock was resolved.
This article explains the limitations of local locks in distributed systems and provides detailed implementations of distributed locks using Redis (SETNX, Lua scripts, Redisson) and ZooKeeper (ephemeral sequential nodes), complete with code examples and best‑practice recommendations.
This article explains the drawbacks of traditional high‑latency timeout centers and presents a Redis‑based low‑latency design, detailing task storage, scheduling, topic and queue structures, two‑phase consumption, retry control, and the resulting performance and reliability benefits.
This article explains how to handle duplicate user requests—especially write operations—by using unique request IDs with Redis, computing MD5 hashes of sorted JSON parameters, and providing a Java helper class to reliably deduplicate requests on the server side.
This article walks through Redis's startup sequence, explaining how the server creates a listening socket, registers events with the aeFileEvent system, runs a single‑threaded select‑based event loop, and processes client commands using the Reactor pattern, complete with code examples and diagrams.
This article explains how Redis read‑write separation works, compares star and chain replication architectures, and highlights the benefits of transparent compatibility, high availability, and high performance for read‑heavy, write‑light workloads.
This article explains how to protect data exchange with third‑party systems by using access tokens, timestamps, cryptographic signatures, and duplicate‑submission safeguards, providing detailed Java/Spring Boot examples and code snippets for implementing secure API authentication and request validation.
This article explains how to use Jedis to create and delete a Redis distributed lock, demonstrates a setNX‑based locking strategy with expiration, and simulates a 100,000‑user concurrent order‑抢单 scenario to show lock acquisition, order processing, and release in Java.
This guide walks through building a highly available Harbor container registry across multiple nodes by selecting a shared storage backend, configuring Redis and PostgreSQL as external services, mounting Alibaba Cloud high‑performance NAS via NFS, and exposing the service through Alibaba SLB.
The article introduces the pain points of using Redis at Tencent IEG, explains the three Tendis product editions, and provides an in‑depth description of the hybrid storage version’s architecture, components, version control, cold‑hot data interaction, scaling mechanisms, and the stateless Redis‑sync layer.
This article compiles 40 frequently asked Redis interview questions covering fundamentals, data types, persistence, clustering, performance tuning, memory optimization, security, and advanced usage such as pipelines and distributed locks, providing concise answers to help candidates prepare confidently for technical interviews.
This article introduces the pain points of using Redis as a cache, presents Tencent's Tendis solution with its three product variants, and provides an in‑depth explanation of the hybrid storage version’s overall architecture, component functions, version control, cold‑hot data interaction, eviction policies, and scaling mechanisms.
The article introduces Transparent Multilevel Cache (TMC), a comprehensive caching solution that adds hotspot detection and local caching to existing distributed cache systems, explains its three‑layer architecture, transparent Java integration, real‑time hotspot discovery process, and demonstrates performance gains in high‑traffic e‑commerce scenarios.
This article compiles 40 common Redis interview questions and detailed answers, covering Redis fundamentals, data types, persistence mechanisms, performance characteristics, clustering, replication, memory optimization, eviction policies, and practical usage scenarios to help candidates confidently succeed in technical interviews.
This article explains Redis Cluster's decentralized sharding design, the role of master‑slave replication for high availability, and how strong consistency is achieved using consensus protocols such as Raft, highlighting key concepts like global log indexes and commit pointers.
The article shares a developer's post‑interview reflections covering self‑introduction, Spring ecosystem usage, Nacos vs Eureka service discovery, SpringBoot startup mechanics, design patterns, Linux commands, Redis operations, Excel POI handling, SQL optimization techniques, and other practical interview questions.
A sysadmin narrates how he monitors four Redis nodes, detects master failure with PING, promotes a slave using SLAVEOF, reconfigures the remaining replicas, and ultimately automates the entire process with a custom Sentinel program and a multi‑node Sentinel cluster for high availability.
This article explains how to use Redis Bitmap for binary state statistics such as user login status and daily sign‑in tracking, demonstrating memory‑efficient storage, relevant commands, and techniques for counting continuous sign‑ins across massive user bases.
This article examines the challenges of storing massive DMP ID mappings in Redis—including memory fragmentation, expansion, and latency constraints—and presents eviction, bucket‑hashing, and fragmentation‑reduction techniques to achieve efficient, real‑time, large‑scale key‑value storage.
This article explains the typical order‑payment flow, identifies common causes of lost orders—both external and internal—and provides concrete backend techniques such as intermediate payment states, timeout queries, idempotent notifications, and Redis‑based duplicate‑submission prevention to ensure reliable order processing.
The article presents a real‑time quantile solution using the TDigest data structure, which clusters data into centroids and stores digests in Redis or Doris, pre‑computes quantiles for all dimension combinations, and provides a reusable API that delivers fast, accurate, low‑memory quantile statistics for diverse business scenarios.
This article enumerates common Redis pitfalls—including unexpected key expiration loss, command‑induced blocking, memory‑intensive bitmap operations, AOF and RDB persistence issues, and master‑slave replication quirks—explaining their causes, real‑world impact, and practical mitigation steps.
This article explains how to integrate Redisson into a Spring Boot application to implement various Redis‑based distributed synchronization primitives—including re‑entrant locks, read‑write locks, and semaphores—while covering configuration, code examples, the watchdog mechanism, and practical testing procedures.
Over four years at Ele.me, the author chronicles the transformation of the order platform from a single‑machine Python monolith to a distributed, sharded, message‑driven architecture, detailing challenges in scaling, performance testing, fault injection, Redis usage, and service separation that shaped today’s robust backend.
This article walks through the design of a flash‑sale system, starting with a simple SpringBoot‑MyBatis implementation, then addressing overselling with pessimistic and optimistic locks, applying rate‑limiting algorithms, time‑window controls, interface hiding, frequency limits, and a suite of production‑grade optimizations such as CDN, Nginx load balancing, Redis caching, message queues, and short‑URL handling.
Vivo’s live‑streaming IM system combines short‑polling and long‑connection techniques, Redis SortedSet storage, priority‑based routing, protobuf compression, and discard strategies to deliver a fault‑tolerant, high‑concurrency messaging backbone that scales with growing traffic and diverse message types.
This article walks through Redis's architectural journey, covering single‑node basics, data persistence strategies (RDB and AOF), master‑slave replication, automatic failover with Sentinel, consensus algorithms, and both client‑side and server‑side sharding to achieve high performance and high availability.
This article explains why Redis can lose data during asynchronous master‑slave replication failures or split‑brain partitions, and shows how configuring min‑slaves‑to‑write and min‑slaves‑max‑lag, along with client‑side fallback strategies, can greatly reduce the risk of loss.
This article introduces Govern Service, a low‑cost SDK for service registration, discovery, and configuration built on Redis, and walks through Maven dependencies, provider and consumer implementations, YAML configuration, and configuration management with code examples.
This article introduces Redis string data type and explains five basic commands (SET, GET, INCR, DECR, APPEND) as well as five commonly used commands (STRLEN, GETRANGE, SETRANGE, MSET, MGET), providing syntax, behavior, and example outputs.
This article examines why local locks fail in distributed systems, introduces Redis‑based distributed locking, and walks through five progressive solutions—from a simple SETNX implementation to atomic Lua scripts—highlighting each approach's drawbacks and how to mitigate them.
This article explains how to implement a user check‑in feature using two approaches—direct MySQL storage and Redis bitmap—detailing database schema, sign‑in logic, code examples, and a comparison of their advantages and disadvantages for backend development.
In high‑traffic e‑commerce systems, caching—ranging from simple in‑JVM HashMap caches to Guava, Caffeine, and Redis distributed stores—reduces latency by applying eviction policies such as FIFO, LRU, LFU, or W‑TinyLFU, while employing consistency strategies like expiration, write‑through, and cache‑aside to mitigate breakdown, avalanche, and penetration issues.
This article provides a concise tutorial on essential Redis commands, covering basic operations, database selection, key management, expiration settings, and practical examples demonstrated through the Redis CLI, including how to list keys with patterns, check existence, and clear databases.
This article provides a comprehensive analysis of Redis Cluster, covering node and slot assignment, command execution, resharding, redirection, failover, gossip messaging, and communication overhead, while explaining why clustering is needed, how it works, and how to deploy and manage it effectively.
This article compares several Java-based approaches for implementing delayed tasks, including database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets and keyspace notifications, and RabbitMQ dead‑letter queues, analyzing their advantages, disadvantages, and code implementations.
This article examines the challenges of storing massive DMP data in Redis, analyzes memory fragmentation, key‑size issues, and latency constraints, and presents practical strategies such as TTL eviction, bucket‑hashing, custom key compression, and fragmentation‑reduction techniques to enable scalable, real‑time querying.
This article outlines Redis's key advantages such as high performance and flexible data types, discusses its limitations like lack of relational features, describes ideal in‑memory use cases, compares it with Memcached, and provides detailed instructions for shutting down, configuring, and connecting to Redis using command‑line and graphical clients.
This article compares Redis list, Kafka, and Pulsar as messaging middleware, explaining their architectures, strengths, and weaknesses—including queue fundamentals, partitioning, cursor management, consumer groups, high‑availability mechanisms, storage strategies, and consumption models—to help readers choose the right solution for large‑scale systems.
Redis read/write separation introduces read‑only replicas to offload read traffic, offering two replication models—star replication with direct master‑replica sync and chain replication forming a replication chain—each with distinct performance, scalability, and latency trade‑offs, while maintaining high availability and transparent compatibility.
This article examines why database caching is needed, outlines the consistency challenges of using Redis as a MySQL cache, and compares four practical solutions—from simple TTL expiration to binlog subscription—helping developers select the most suitable approach for their latency and reliability requirements.
This article examines why caching is needed for MySQL, discusses consistency challenges, and compares four Redis‑based solutions—including expiration, synchronous updates, Kafka‑mediated async updates, and binlog replication—offering guidance on selecting the appropriate approach based on latency and reliability requirements.
This article provides a step‑by‑step tutorial on building a Spring Boot project, covering project generation, core starters, automatic Redis configuration, common annotations like @SpringBootApplication and @ControllerAdvice, web container and HTTPS settings, profile management, CORS, MVC interceptors, AOP, MyBatis‑Druid integration, mail sending, and Swagger API documentation.
This article explains Redis's single‑threaded event loop, the impact of adding CPU cores, compares Redis with Memcached, discusses persistence suitability, synchronization methods, security concerns, request ordering, operation complexity, latency, and defines what constitutes a big key.
An operations engineer narrates how he monitors a four‑node Redis cluster, detects master failure with continuous PINGs, promotes a slave to master, reconfigures replicas, and automates the entire process with a sentinel program and a sentinel cluster for high availability.
This article explains the typical payment flow, identifies causes of external and internal order loss, and provides concrete backend strategies—including intermediate payment states, timeout queries, idempotent handling, retry mechanisms, and Redis‑based duplicate‑submission protection—to ensure reliable order processing.
The article analyzes the massive storage and performance challenges of a real‑time DMP cache built on Redis, outlines data characteristics and technical obstacles, and proposes eviction policies, bucket‑based hashing, and fragmentation‑reduction techniques with Java code examples to achieve billion‑scale in‑memory key‑value storage.
This article analyzes a real‑world flash‑sale incident where a Redis distributed lock expired under high concurrency, leading to massive overselling, and presents safer lock implementations, atomic stock checks, and architectural improvements to prevent similar failures.
This article explains Redis Sentinel's role in providing high availability for Redis by detailing its architecture, monitoring, leader election, automatic failover process, configuration of master‑slave instances and sentinel nodes, and how clients can subscribe to sentinel events.
This article explains why local in‑memory locks fail in distributed environments, introduces the concept of distributed locks, and walks through five progressive Redis‑based lock implementations—bronze, silver, gold, platinum, and diamond—detailing their principles, code examples, advantages, and shortcomings.
This article explains common causes of Redis latency spikes—including slow commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network saturation—and provides step‑by‑step diagnostic commands and practical mitigation techniques.
This guide outlines Redis's fundamental limitations, common performance issues such as big keys, slow queries, and connection‑pool exhaustion, and provides practical recommendations on architecture, configuration, and operational diagnostics to help developers avoid hitting Redis's boundaries.
This guide walks beginners through setting up a basic live‑streaming pipeline using the open‑source LiveGo server, OBS for RTMP publishing, and flv.js for browser playback, while explaining push‑pull architecture, protocol choices, Docker deployment, and a Redis‑based chat system for live rooms.
This article demonstrates how to create a custom @AccessLimit annotation, implement a Spring Boot interceptor that uses Redis to track request counts, register the interceptor, and apply the annotation to controller methods for fine‑grained rate limiting.
This article compares the fundamentals and limitations of Redis list‑based queues with Kafka and Pulsar, explaining how partitions, cursors, replication, segment storage, and consumption models overcome Redis’s drawbacks and enable high‑performance, scalable, and highly available messaging systems.
This article compares the fundamentals and design trade‑offs of popular message‑queue middleware—Redis list, Kafka, and Pulsar—explaining their data structures, partitioning, persistence, consumer models, high‑availability mechanisms, and scalability challenges for developers and architects.
This article provides a comprehensive analysis of Redis Cluster, covering node and slot assignment, command execution, resharding, redirection, fault‑tolerance, gossip communication, scaling strategies, configuration limits, and practical code examples for building and operating a high‑availability sharded Redis deployment.
This article details Zhihu’s transition from a Sqoop‑driven data integration system to a Flink‑centric platform, covering business scenarios, historical architecture, design goals, technology choices, performance optimizations, and future plans for unified streaming‑batch processing across diverse storage systems.
This article explains what rate limiting is, why it is needed, the typical actions triggered by limiting, compares single‑node and distributed architectures, reviews four common limiting algorithms, and provides a detailed Redis‑Lua token‑bucket implementation with full source code.
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.
This guide compiles 21 practical Redis usage guidelines covering key naming conventions, value size limits, expiration strategies, batch operations, risky commands, distributed lock patterns, cache consistency, capacity planning, and common pitfalls like cache penetration, snowball, and hot‑key issues, helping developers and operators build reliable, high‑performance Redis deployments.
This article explains how to improve Spring Cloud microservice performance by adding local and Redis distributed caching, demonstrates the necessary code changes, and discusses cache pitfalls such as penetration, avalanche, and breakdown along with lock‑based solutions.
The article explains how asynchronous replication and split‑brain situations can cause data loss in Redis clusters, and describes configuration parameters and client‑side techniques to minimize such loss while maintaining high availability.
This article introduces Redis, explains why it is popular, describes the architecture of a Redis Cluster, and provides a complete step‑by‑step tutorial for deploying, initializing, validating, and testing a Redis Cluster on Kubernetes with sample code and a hit‑counter application.
This article describes a real-time log processing platform that integrates Kafka, Flink, Drools rule engine, Redis, and Elasticsearch to unify heterogeneous log formats, extract business metrics, and provide configurable, dynamic data processing for large‑scale logging scenarios.
This article examines a real‑world incident where a Redis‑based distributed lock caused a 100‑bottle oversell of a scarce product, analyzes the root causes such as lock expiration and non‑atomic stock checks, and presents safer lock and stock‑validation solutions using Lua scripts and atomic Redis operations.
This comprehensive guide covers the core concepts of distributed systems—including CAP theory, consistency models, transaction protocols like 2PC/3PC and TCC, Redis features, persistence options, expiration strategies, memory eviction policies, distributed locking with Redis and Zookeeper, as well as an overview of Kafka's architecture and reliability mechanisms.
This comprehensive guide covers core distributed system theories, CAP consistency, transaction protocols, Redis features and persistence, Zookeeper coordination, message queue fundamentals, Kafka performance tricks, and practical solutions for caching, locking, and high‑concurrency scenarios.
This article walks through installing Docker Desktop on Apple M1 Macs, explains required Rosetta support, shows how to run and manage containers—including a Redis example—covers Docker Desktop preferences, resource settings, and built‑in Kubernetes, and highlights practical tips and known limitations.
This article compiles 40 common Redis interview questions covering fundamentals, data types, persistence, clustering, performance tuning, memory optimization, and practical usage patterns, providing concise answers that help candidates confidently tackle Redis topics and secure job offers during the competitive hiring season.
This weekly community newsletter compiles the latest technical updates, including MySQL and ProxySQL troubleshooting articles, Redis memory diagnostics, InnoDB performance insights, as well as progress reports and upcoming plans for the open‑source middleware projects DBLE and DTLE.
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.
This article explains why Redis can report out‑of‑memory (OOM) errors even with small datasets, describes the two types of OOM, outlines memory‑consumption categories, presents systematic troubleshooting methods, and provides a collection of useful Redis commands for diagnosing and resolving memory‑related issues.
This tutorial walks through building a scalable like feature using Spring Cloud, Redis caching, MySQL persistence, and Quartz scheduling, covering Redis installation, Spring Boot integration, data modeling, service implementation, and periodic synchronization of high‑frequency like operations to the database.
This article explains Redis's clean and elegant I/O multiplexing implementation, covering blocking I/O limitations, the reactor pattern, abstraction of select/epoll/kqueue into a unified API, key source functions, and platform‑specific module selection to achieve high‑performance single‑threaded networking.
This article compares common globally unique ID generation methods—including database auto‑increment, batch services, UUID/GUID, timestamp‑based IDs, Redis INCR, and Twitter’s Snowflake—detailing their advantages, drawbacks, and improvement options to help developers select the most suitable approach for scalability and ordering needs.
The article explores what makes code 'good'—emphasizing usability, readability, and maintainability—then details the design and implementation of a lightweight Redis‑based distributed consumption queue that alleviates HBase I/O pressure, describing its architecture, modules, logging, and performance gains.
This article explains why using the KEYS command on large Redis keyspaces can crash the service and demonstrates how the SCAN command provides a non‑blocking, incremental way to iterate over massive data safely.
This article explains how to build a highly available Redis service by analyzing common failure scenarios, evaluating single‑instance, master‑slave with one or multiple Sentinel processes, and ultimately recommending a three‑Sentinel architecture combined with a virtual IP for seamless client usage.
Redis, traditionally single‑threaded for network I/O and key‑value operations, introduced multithreading in version 6.0 to improve network I/O handling; this article explains the original single‑thread design, when multithreading is appropriate, its drawbacks, the role of I/O multiplexing, and why Redis still keeps most work single‑threaded.
This article explains the causes of partial resynchronization failures, master‑slave data inconsistency, latency, dirty data, and data‑safety risks in Redis replication, and provides concrete configuration commands and mitigation strategies to ensure reliable data consistency.
This article provides a comprehensive guide to Redis, covering its role as a non‑relational database, detailed data types and commands, persistence mechanisms (RDB and AOF), memory eviction strategies, high‑availability features such as replication, Sentinel and clustering, and solutions to typical cache problems like penetration, avalanche, and hot‑key handling.
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.
This article explains the LRU (Least Recently Used) caching principle, shows how to build an O(1) LRU cache using a HashMap and doubly linked list in Java, and describes Redis's approximate LRU eviction algorithm based on a global clock and random sampling.
This article examines cache consistency challenges in Redis-backed systems and compares several update strategies—including TTL, delayed double‑delete, cache‑aside, and message‑queue approaches—detailing their workflows, code examples, advantages, and drawbacks to guide backend developers toward reliable cache invalidation.
This article walks through what Redis is, its data types, caching usage with Spring Boot, performance advantages, eviction policies, persistence mechanisms, master‑slave replication, Sentinel high‑availability, and practical interview‑style Q&A, providing a comprehensive guide for backend developers.
This article explains how Redis Sentinel provides high‑availability for Redis by continuously monitoring master and replica nodes, detecting failures through subjective and objective down states, electing a new master via quorum‑based voting, and notifying clients of the failover using Pub/Sub events.
This article explains how Redis master‑slave replication operates, covering the underlying mechanisms such as update propagation, partial and full resynchronization, the characteristics and limitations of replication, common single‑node issues, and step‑by‑step instructions for configuring and executing replication commands.
This article explains Redis fundamentals, its typical use cases, and presents a detailed cloud‑native deployment architecture on Kubernetes—including Server, Proxy, ConfigServer components, placement strategies, storage handling, scaling, and upgrade procedures—illustrated with diagrams and practical operator workflows.
This article compiles 21 practical Redis guidelines covering key naming, value sizing, expiration strategies, batch operations, risky commands, distributed lock patterns, cache consistency, capacity planning, and configuration tips, helping developers and operators build reliable, high‑performance Redis‑backed systems.
This article walks through the design, core components, task states, API endpoints, and full Java implementation of a Redis-powered delay queue using Spring Boot, complete with code samples, container structures, timer processing, and testing procedures.
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.
This article explains why Redis achieves exceptionally high performance by combining pure in‑memory operations, a global hash table with O(1) lookups, efficient data structures such as SDS, ziplist, quicklist and skiplist, a single‑threaded event loop with non‑blocking I/O multiplexing, and adaptive encoding strategies.
This article presents a comprehensive design of a real‑time security monitoring and alert platform, detailing challenges in high‑concurrency risk control, an architecture that replaces OLAP polling with scalable compute services, event‑time processing, dynamic thresholding using fbprophet, and practical optimizations with Redis and ClickHouse.
This article examines common distributed ID generation methods—including UUID, MySQL auto‑increment, multi‑instance auto‑increment, Snowflake, and Redis—detailing their advantages, drawbacks, and practical use cases, and presents advanced designs such as database‑driven ID blocks, concurrency handling, and double‑buffer techniques for high‑traffic systems.
This article compiles 40 frequently asked Redis interview questions, covering its definition, data types, advantages, comparison with Memcached, persistence mechanisms, performance considerations, eviction policies, clustering, client libraries, security commands, usage scenarios, and best‑practice tips for high‑traffic production environments.
This article explains the concept of idempotency, why it is essential for HTTP interfaces, the impact on system design, and presents several practical implementation strategies—including unique primary keys, optimistic locking, anti‑repeat tokens, and downstream sequence numbers—accompanied by a complete Spring Boot example with Redis integration and test code.
When a Redis key stores a very large value, it can block the single‑threaded server and waste memory, so this article explains practical techniques such as splitting keys, using hash structures, and bucket‑based hashing to reduce I/O pressure and memory consumption.
