This article outlines ten essential Redis best‑practice tips, covering why to avoid the KEYS * command, using SCAN, interpreting INFO stats, leveraging hashes, setting key expirations, choosing eviction policies, handling errors, scaling with clusters, CPU considerations, and ensuring high availability with Sentinel.
This article analyzes the extreme‑traffic problem of Chinese train ticket sales, presents a multi‑layer load‑balancing architecture with Nginx weighted round‑robin, demonstrates Go and Redis code for local and global stock deduction, and shows benchmark results proving that a single machine can handle over 4 000 requests per second while preventing oversell and few‑sell.
This guide outlines the key Redis monitoring metrics—including performance, memory, activity, persistence, and error indicators—provides detailed descriptions, command examples, and practical tips for using tools like redis-cli, redis-benchmark, and info commands to effectively track and troubleshoot your Redis instances.
Spring Boot 2.6 introduces Cookie SameSite support, reactive session timeout, custom data‑masking rules, automatic Redis pool configuration, richer runtime Java metrics, build‑info personalization, new startup and disk metrics, enhanced Docker image building, and many deprecated properties removed or renamed, improving security and performance.
The paper presents a unified alert convergence system that centralizes metric calculation, detection, and alarm handling across monitoring subsystems, employing mechanisms such as convergence, claiming, silencing, escalation, and a Redis‑based delayed queue integrated via Kafka or REST to reduce alarm fatigue, improve MTTA/MTTR, and enable future AI‑driven AIOps.
This article explains the principles and practical implementations of distributed locks using Redis (SETNX and SET with expiration), Redisson's Java client, and Zookeeper's sequential ephemeral nodes, providing code examples, lock acquisition and release mechanisms, and a comparison of their advantages and drawbacks.
This tutorial walks through Kubernetes architecture, cluster setup methods, and a step‑by‑step Redis deployment using Pods, Deployments, StatefulSets, and an Operator SDK example, illustrating core concepts and practical commands for building reliable cloud‑native applications.
This guide explains how to use Redis's built-in redis-benchmark tool to simulate concurrent client load, interpret key performance metrics such as request latency and throughput, and monitor server resource usage, helping operators prevent cache-related failures like penetration and avalanche after deployment.
This article demonstrates how to achieve automatic request idempotency in Spring Boot applications by leveraging Redis for token storage, custom annotations, and a handler interceptor, detailing the underlying concepts, code implementation, configuration, and testing procedures to prevent duplicate processing.
This article explains how to achieve reliable API idempotency in Spring Boot applications by using Redis for token storage, defining a custom @AutoIdempotent annotation, configuring an interceptor to enforce token checks, and providing complete Java code examples and testing steps.
Full‑chain load testing uncovered a Redis large‑key bottleneck that saturated bandwidth, a memory‑leak caused by repeatedly registering shutdown hooks, and persistently high JVM heap usage, leading to solutions of key sharding with local caching, registering hooks only once, and adjusting heap size, physical memory, and alert thresholds.
In a large‑scale Redis cluster, expanding nodes caused unexpected CPU spikes and higher latency for MGET operations, prompting a deep investigation that traced the issue to the CLUSTER SLOTS command and its handling of MOVED errors, followed by a code‑level optimization that reduced CPU usage by over 90% and cut command latency dramatically.
This article explains why rate limiting is needed for high‑traffic Java services, reviews common throttling techniques such as Hystrix, Sentinel, token‑bucket algorithms, and then provides multiple concrete implementations—including Guava RateLimiter, Redis counters, interceptor configuration, and Tomcat connector settings—complete with code samples.
This article explains how to build a Redis‑based message queue using RPUSH to enqueue tasks and BLPOP to consume them in a PHP backend, illustrating the configuration, execution flow, and sample code for processing cancel‑order jobs in a high‑concurrency environment.
This article explains Redis Sentinel’s role in high‑availability deployments, covering its architecture, monitoring and notification mechanisms, automatic failover process, configuration steps for master‑slave and sentinel nodes, and practical guidelines for building a reliable Redis cluster.
This article explains the different types of auto‑increment identifiers used by MySQL—including table primary keys, InnoDB row_id, Xid, trx_id, and thread_id—describes how they reach their maximum values, the consequences of overflow, and compares external solutions such as Redis‑based keys.
This article outlines HuoLaLa's journey from a fragmented multi‑cloud environment to a unified, platform‑driven database governance system, detailing the technical challenges, architectural decisions, key components for MySQL, Redis, Kafka, and other middleware, and the measurable stability and cost improvements achieved after a year of operation.
This article demonstrates how to design and implement a high‑frequency like/unlike feature using Spring Cloud, Redis for caching, MySQL for persistence, and Quartz for scheduled data synchronization, covering cache design, data structures, service interfaces, database schema, and deployment scripts.
This article explains three practical Redis-based rate‑limiting techniques—using SETNX for simple counters, ZSET for a sliding‑window algorithm, and a token‑bucket implementation with List—complete with Java code examples and discussion of their advantages and drawbacks.
This article explains how to use Redis Bitmap to efficiently store and query massive binary‑state data such as user login status and daily sign‑in records, covering underlying memory structures, command usage, and practical examples for counting, checking, and aggregating large‑scale user activity.
This article walks through the challenges of multi‑user WebSocket communication in a clustered environment and presents two practical solutions—session broadcasting and a consistent‑hashing based routing—using Spring Boot, Spring Cloud Gateway, Redis, Netty, and Ribbon to achieve scalable, reliable real‑time messaging.
This article explains how to design a robust e‑commerce shopping‑cart service by separating business, system, and technical architectures, applying DDD, strategy and chain‑of‑responsibility patterns, and choosing Redis data structures for high‑performance storage.
This article explains Redis’s overall architecture, covering its data model, supported value types, operation interfaces, memory versus disk storage choices, access pattern selection, I/O threading models, indexing mechanisms, specific CRUD logic, and persistence strategies, helping readers grasp both high‑level design and detailed implementation.
This article explains three Redis‑based rate‑limiting methods—using SETNX, a ZSET sliding window, and a token‑bucket with List—provides Java code examples, and discusses their advantages, drawbacks, and how to integrate them into backend services.
An in‑depth post examines a P0 flash‑sale incident where a Redis‑based distributed lock caused severe overselling, analyzes root causes such as lock expiration and non‑atomic stock checks, and presents safer lock release via Lua scripts and alternative designs to prevent similar failures.
This article analyzes data consistency challenges between databases and Redis caches in high‑traffic applications, examines write order pitfalls and concurrency issues, and presents the Cache‑Aside pattern with retry and expiration strategies to achieve eventual consistency.
This article explains why Redis is widely used, defines high availability for Redis services, enumerates common failure scenarios, evaluates four architectural solutions—including single‑instance, master‑slave with one, two, and three Sentinel instances—and finally presents a production‑grade HA design using three Sentinels and a virtual IP.
This article provides a thorough overview of Redis, covering its core data structures and common commands, persistence options, memory management and eviction policies, pipelining, transactions, Lua scripting, performance optimization techniques, replication with Sentinel, cluster sharding, and a comparison of popular Java clients.
This article explains the concepts, characteristics, and architectural design of a flash‑sale (秒杀) system, covering rate‑limiting, peak‑shaving, asynchronous processing, caching, scalability, and concrete Redis‑based implementation details for handling massive concurrent requests.
This article explains why Redis needs high availability, defines common failure scenarios, compares several HA architectures—including single‑instance, master‑slave with one or multiple Sentinel processes, and VIP‑based solutions—and provides step‑by‑step guidance for deploying a robust Redis Sentinel cluster.
The author, a second‑year master's student in Java backend development, summarizes interview questions and experiences from JD, Meituan, Alibaba, Toutiao and Kuaishou, covering Java concurrency, JVM locking, Netty, Redis, MySQL/HBase, distributed systems, and several algorithm problems.
This article explains how to build a dynamic IP blacklist using Nginx, Lua, and Redis, covering installation, configuration, Lua scripting, and deployment steps to reject requests from blacklisted IPs while keeping the solution lightweight and shareable across multiple servers.
The article explains why cache breakdown, penetration, and avalanche occur under high concurrency, analyzes their root causes such as key expiration and eviction, and provides practical mitigation techniques including distributed locking, Bloom filters, and staggered key updates to keep services stable.
The article explains why cache breakdown, penetration, and avalanche occur in high‑concurrency Redis environments, and presents practical mitigation techniques such as distributed locking, Bloom‑filter filtering, and careful expiration strategies to keep backend services stable.
This article examines the challenges of building a flash‑sale system—such as overselling, massive concurrent requests, URL exposure, and database pressure—and presents a comprehensive backend design that includes dedicated databases, dynamic URLs, static pages, Redis clustering, Nginx load balancing, SQL optimization, token‑bucket rate limiting, asynchronous order processing, and service degradation techniques.
The article reviews the most frequent errors encountered while adopting microservice architecture—excessive customization, uncontrolled complexity, and vague definitions—illustrating each with real‑world experiences, a saga implementation using Redis streams and Go, and practical advice to avoid similar pitfalls.
This article explains how Redis, an in‑memory key‑value store, ensures data durability through two persistence methods—RDB snapshots and AOF command logging—detailing their commands, internal workflows, file structures, configuration options, and trade‑offs between safety and performance.
The article examines Jedis 3.5.0’s three Redis access modes—single‑node via Jedis, sharding via ShardedJedis, and cluster via JedisCluster—detailing their class hierarchies, connection handling, consistent‑hashing and slot logic, and how pipelines boost throughput while respecting mode‑specific constraints.
The article explains the concept of delayed tasks, distinguishes them from scheduled tasks, and evaluates five practical implementation approaches—including database polling, JDK DelayQueue, Netty time‑wheel, Redis sorted‑set and key‑space notifications, and RabbitMQ delayed queues—while providing code samples, performance pros and cons, and deployment considerations.
This article explains Redis's ziplist—a compact list implementation used for small integers and short strings—by detailing its memory layout, field meanings, entry encoding schemes, the role of previous_entry, and the chain‑update behavior that occurs when nodes are added or removed.
This article examines frequent Redis pitfalls—including unexpected key expiration, blocking DEL commands, RANDOMKEY performance issues, SETBIT memory spikes, MONITOR OOM risks, persistence challenges, and master‑slave replication quirks—providing detailed explanations and practical mitigation strategies for each scenario.
When a Dubbo interface handling 18 billion daily requests began failing due to thread‑pool exhaustion, a systematic investigation uncovered traffic spikes, Redis request overload, and mis‑configured connection‑pool parameters, leading to a series of targeted fixes—including timeout adjustments, Redis scaling, and pool‑parameter tuning—that restored stability and dramatically reduced error rates.
This article explains how to build a highly available Redis service using Redis Sentinel, covering failure scenarios, design principles, four architectural options, the final three‑Sentinel solution with virtual IP, and practical operational tips for ensuring continuous service.
This article provides a detailed overview of Celery, covering its architecture, common use cases, installation steps, project structure, task definition, periodic tasks, worker management, distributed deployment, advanced monitoring, custom task handling, task routing, and monitoring with Flower, all illustrated with practical code examples.
This article thoroughly examines how Redis distributed locks work, the safety challenges they face—including deadlocks, lock expiration, and node failures—explores the Redlock algorithm and its controversies, compares Redis with Zookeeper implementations, and offers practical guidelines and best‑practice solutions for reliable distributed locking.
This article presents a practical seven‑step methodology for efficiently reading Redis's source code—starting with project mapping, preparing prerequisite knowledge, tackling basic modules, following the core execution flow, using a whole‑before‑detail approach, exploring side features, and finally filling knowledge gaps—applicable to other large codebases as well.
This tutorial explains the concept of idempotency in web APIs and demonstrates a complete Spring Boot solution using Redis, custom annotations, token validation, and interceptor configuration to ensure that each request modifies the database only once, even under repeated calls.
This guide shows how to build a real‑time UV and PV analytics pipeline on Tencent Cloud Oceanus by connecting a self‑hosted Kafka cluster to Flink SQL, using Redis for deduplicated visitor counts, page view logs, and conversion‑rate calculations via hop windows.
This article describes a real‑time slow‑query monitoring solution for MySQL, detailing the overall architecture, the agent that tails slow‑log files and pushes entries to Redis, and the consumer that processes logs, stores them, and alerts DBAs, enabling near‑instant detection of performance issues.
This guide explains how to use OpenResty’s Lua modules to let Nginx read and write Redis directly, compress large payloads, schedule periodic cache updates, and configure URL‑based caching, thereby reducing latency, saving bandwidth, and improving overall backend reliability.
This article introduces various Redis scaling solutions—including basic partitioning, master‑slave replication, Sentinel high‑availability, and Redis Cluster—explaining their concepts, typical usage patterns, configuration commands, advantages, and drawbacks to help developers choose the right approach for high‑traffic environments.
This article analyzes a Maven multi‑module project where a static constant change in a shared API module caused unexpected Redis key errors at runtime due to JDK compile‑time constant folding, outlines the investigation steps, identifies the root cause, and provides best‑practice recommendations for version management.
This article explains the fundamentals of ACID, how Redis implements transactions with MULTI, EXEC, DISCARD and WATCH commands, provides code examples, and analyzes whether Redis transactions satisfy atomicity, consistency, isolation, and durability.
This article explains how to monitor Redis by categorizing essential performance, memory, activity, persistence, and error metrics, provides detailed tables of metric names and descriptions, lists common monitoring tools, shows configuration snippets, and demonstrates useful Redis CLI commands for real‑time insight.
This article explains how to use OpenResty with Lua to integrate Nginx and Redis for high‑performance caching, data compression, timed updates, and configurable URL management, enabling resilient backend services that continue serving content even when application servers fail.
Learn how to build a pure Go instant messaging platform with a three‑layer, distributed architecture—comet, logic, and job—featuring RPC communication, Redis‑based message pushing, and cluster support, plus step‑by‑step deployment instructions, required packages, and future enhancement plans.
This article explains how Redis can be used to implement and simplify a wide range of microservice design patterns—including bounded contexts, asynchronous messaging, orchestrated sagas, transaction inboxes, telemetry, event sourcing, CQRS, and shared data—while improving performance, scalability, and observability in cloud‑native architectures.
This article explains the main Redis scaling approaches—including simple partitioning, master‑slave replication, Sentinel high‑availability, and native Cluster—detailing their concepts, usage methods, advantages, drawbacks, and providing practical configuration commands and code examples.
This article explains what data consistency means for MySQL and Redis, analyzes inconsistency cases in both single‑threaded and concurrent environments, and proposes practical strategies—including read‑only and read‑write cache handling, message‑queue retries, binlog subscription, delayed double‑delete, and distributed locking—to achieve eventual or strong consistency.
This article details the JD Daojia coupon system's high‑traffic architecture, describing its multi‑layer design, Redis cache challenges such as large‑key and hot‑key issues, and practical optimization techniques including key redesign, expiration strategies, and active‑expire algorithms to improve performance and scalability.
This article investigates the high CPU usage and latency observed after expanding a large Redis cluster, analyzes the root cause in the CLUSTER SLOTS implementation and client MOVED handling, proposes an optimized slot‑traversal algorithm, and demonstrates significant performance improvements through benchmarking and profiling.
This article explains practical API security techniques—including access tokens, timestamps, cryptographic signatures, and anti‑replay measures—illustrated with Java Spring Boot code, Redis storage, custom annotations, and ThreadLocal usage to protect data exchange between services.
This article provides a comprehensive overview of rate‑limiting techniques for Spring Cloud Gateway, covering common scenarios, classic algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, and practical implementations using Redis, Resilience4j, Bucket4j, Guava and custom local limiters.
This guide explores sixteen practical Redis use cases—from caching and distributed locks to rate limiting, bitmaps, shopping carts, timelines, and ranking—detailing data types, commands, and implementation tips that help developers build efficient, scalable backend services.
In large Redis clusters the original CLUSTER SLOTS implementation traversed every master and all 16,384 slots, causing ~52 % CPU usage and high MGET latency during migrations, but redesigning it to iterate the pre‑built slot array reduced complexity to O(total slots), cutting execution time from 2 ms to 0.17 ms and eliminating the CPU hotspot, a fix now merged into Redis 6.2.2.
To keep MySQL and Redis synchronized, the article defines consistency, examines read‑only and read‑write cache inconsistency cases, and recommends practical strategies such as update‑DB‑then‑delete‑cache with message‑queue retries, binlog‑driven updates, delayed double‑delete, and Redis distributed locks, while outlining stronger protocols and key design considerations.
This article presents a practical, seven‑step methodology for efficiently reading Redis source code, covering project mapping, prerequisite knowledge, starting from basic modules, identifying the core execution path, balancing overall structure with detailed logic, handling auxiliary features, and performing targeted gap‑filling to master the codebase.
This guide walks through installing Redis, MariaDB, Go, configuring Open-Falcon's backend and frontend components, setting up Python virtual environments, and launching the monitoring system, providing complete command-line instructions and configuration details for a functional deployment.
Learn how to use Redis's built-in redis‑benchmark tool to simulate concurrent clients, configure request parameters, interpret performance metrics, and visualize results, ensuring your Redis deployment is properly tested for throughput, latency, and resource utilization before production.
This comprehensive guide covers Redis fundamentals, data structures, performance tricks, cache pitfalls, expiration policies, persistence options, high‑availability architectures, distributed locking techniques, and practical use‑cases, providing clear explanations and code examples for each topic.
This article explains the fundamentals of Redis locking mechanisms, covering SETNX usage, the pitfalls of naive implementations, Lua‑based atomic unlock scripts, the Redisson client library, and the RedLock algorithm, while providing practical code examples and diagrams to illustrate each concept.
This article explains how Redis implements distributed locks using the SET command with NX and PX options, compares plain setnx, Lua‑based atomic unlock scripts, and Redisson’s high‑level APIs including the RedLock algorithm, and provides practical code examples and pitfalls to avoid.
The article explains how a senior architect uses OpenResty and Lua to let Nginx directly access Redis for caching, compresses large responses, schedules periodic updates, and provides a configurable, signature‑verified caching layer to improve web performance and resilience.
This article walks through the challenges of sharing HTTP session data between micro‑services in a distributed SpringBoot architecture, demonstrates a Redis‑based manual solution, introduces Spring Session for transparent session clustering, and resolves OpenFeign cookie loss with a request interceptor.
This guide explains what Redis Sentinel is, its architecture, how to configure it, and demonstrates both slave and master failure recovery as well as configuring multiple Sentinel instances for high availability.
This article explains how to build a high‑concurrency ticket‑seckill system that can handle millions of simultaneous requests by using multi‑layer load balancing, Nginx weighted round‑robin, local stock deduction, Redis atomic scripts, and Go’s native concurrency, and it demonstrates the implementation with complete code and performance testing.
This article compares the three popular Redis Java clients—Jedis, Redisson, and Lettuce—explaining their core differences, then shows how to configure and use Spring's RedisTemplate, RedissonClient, and annotation‑based caching with practical code examples and configuration files.
Redis distributed locks are widely used for ensuring mutual exclusion in distributed systems, but improper implementation can cause issues such as non‑atomic operations, forgotten releases, lock stealing, high contention, re‑entrancy problems, timeout handling, and master‑slave failures; this article explains each pitfall and offers practical solutions and code examples.
This article explains how Redis locking works, covering the setnx command, the importance of using unique values, atomic unlock via Lua scripts, the Redisson client features, and the RedLock distributed algorithm, while highlighting common pitfalls and practical recommendations.
This article explores the most common Redis locking mechanisms—SetNX, RedLock, and Redisson—detailing their principles, pitfalls, and implementation nuances, including code examples, Lua scripts for atomic unlocks, and best‑practice recommendations for building reliable distributed locks in backend systems.
This article explains how Redis locking works by detailing the setnx command, its modern usage with the SET command and PX expiration, common pitfalls, safe unlocking with unique values and Lua scripts, and introduces Redisson's lock implementations and the RedLock algorithm for distributed environments.
This article details the design and implementation of a high‑performance, highly available membership system for the merged Tongcheng‑eLong platform, covering Elasticsearch dual‑center clusters, traffic‑isolated three‑cluster architecture, deep ES optimizations, Redis caching and dual‑center clusters, MySQL dual‑center partitioning, migration strategies, and future fine‑grained flow‑control and degradation measures.
This article demonstrates how to use the FunTester framework to benchmark Redis hash (map) and INCR commands, detailing the test design, Java code implementation, multithreaded execution, and summarizing the observed performance results.
This article compares the Java Redis clients Jedis, Redisson, and Lettuce, explains their distinct features and thread‑safety, and provides detailed Spring Boot configurations and code examples for RedisTemplate, RedissonClient, and cache annotations to implement caching, distributed locks, and atomic operations.
This article explains the challenges of high‑concurrency inventory deduction, demonstrates why simple synchronized locks fail in distributed environments, and walks through multiple solutions—from basic SETNX locks to Redisson’s advanced distributed lock implementation—highlighting pitfalls, expiration handling, and trade‑offs with alternatives like Zookeeper.
This article provides a comprehensive overview of Redis, covering its definition, basic and special data structures, performance optimizations, expiration and eviction policies, common application scenarios, persistence mechanisms, high‑availability architectures, distributed lock implementations, transaction handling, and related algorithms such as Redlock and Bloom filters.
This article explores the design of a high‑concurrency train‑ticket flash‑sale system, covering distributed load‑balancing strategies, Nginx weighted round‑robin configuration, local and remote stock deduction using Go and Redis, performance testing with ApacheBench, and key architectural lessons for preventing overselling and ensuring high availability.
After deploying a new cluster, a 502 error appeared when logging in because traffic to Redis’s 7000 port was intercepted by Istio’s sidecar, which routed it to a BlackHoleCluster; the article details the root cause, Istio’s listener and cluster configurations, and three practical remediation methods.
The author, a senior Java developer with ten years of experience, documents a ten‑day interview marathon across 20 companies, summarizing interview processes, outcomes, and the most frequently asked technical questions on Java fundamentals, Spring, MySQL, Redis, MQ, and micro‑service architecture to help fellow developers prepare effectively.
A Monday morning surge in user traffic exposed a Redis performance crisis, where CPU spiked to 100% due to massive keys* commands, and the investigation using Grafana, Redis info, commandstats, and slowlog revealed the root cause and a temporary mitigation strategy.
This article presents comprehensive Redis usage standards—including key naming conventions, avoiding big keys, efficient serialization, safe command usage, data persistence strategies, and operational recommendations—to ensure high performance, memory efficiency, and reliable service under heavy traffic.
This article explores sixteen practical Redis patterns—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, product filtering, follow relationships, and rankings—demonstrating how each can be implemented with simple Redis commands to enhance performance and scalability.
This guide explains what Redis Sentinel is, its architecture, how to configure it in a master‑replica environment, and demonstrates handling both slave and master failures with detailed log examples, plus tips for running multiple Sentinel instances for high availability.
This article examines the concept of delayed tasks versus scheduled tasks, outlines their differences, and presents five practical implementation strategies—including database polling with Quartz, JDK DelayQueue, Netty’s HashedWheelTimer, Redis ZSET and keyspace notifications, and RabbitMQ delayed queues—complete with code samples, performance pros and cons, and scalability considerations.
This article explains what distributed locks are, their requirements, how to implement them using Redis commands and the Redisson library in Java, and introduces the RedLock algorithm for multi‑node fault‑tolerant locking, complete with code examples and practical considerations.
The article explains the concept of delayed tasks versus scheduled tasks and provides five Java‑based solutions—Quartz polling, JDK DelayQueue, Netty HashedWheelTimer, Redis (zset and keyspace notifications), and RabbitMQ delayed queues—detailing their implementations, advantages, and drawbacks.
This article presents a comprehensive guide to using Redis for caching, distributed data sharing, distributed locks, global IDs, counters, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow relationships, and ranking, complete with code examples.
This article presents sixteen practical Redis use‑cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, tags, filtering, follow models, and ranking—explaining their data types, commands, and sample code.
This article explains the three Redis clustering modes, details how Redis Cluster uses 16384 hash slots calculated by CRC16, describes the rationale behind the slot count, and outlines the gossip‑based heartbeat communication and message format between master nodes.
Redis, an open‑source in‑memory data store, serves as a database, cache, and message broker, offering rich data types, persistence, replication, Sentinel, and clustering; this article walks through its evolution from simple caching to high‑availability, distributed architectures, and advanced client features.
