This article explains how Redis cache can suffer from key expiration, eviction, and high‑concurrency problems such as cache breakdown, penetration, and avalanche, and presents practical lock‑based, filter‑based, and timing‑aware solutions to maintain backend stability and performance.
This article explains how caching can accelerate read/write performance and reduce backend load, analyzes its benefits and costs, discusses update strategies, granularity control, and solutions for common problems such as cache penetration, empty‑hole, avalanche, and hot‑key reconstruction, providing practical guidelines for robust backend design.
This article provides an in-depth tutorial on using Redis for distributed locking, covering when locks are needed, core properties, basic SETNX usage, timeout handling, lock renewal with watchdogs, Redlock algorithm debates, and practical Redisson integration with Java code examples.
This article details the evolution from a Node.js‑based WebSocket gateway to a Go‑implemented, gRPC‑driven architecture, describing the redesign of connection handling, TLS off‑loading, socket ID generation, session management, custom Kafka headers, code‑level optimizations, and extensive performance testing that validates the new gateway’s scalability and resource efficiency.
This article describes the architectural evolution from Gateway 1.0 to Gateway 2.0 for a high‑traffic document collaboration platform, detailing the redesign of the WebSocket layer, resource‑usage optimizations, heartbeat mechanisms, custom Kafka headers, message serialization, load‑testing results, and the operational lessons learned to support millions of concurrent connections.
This article details the redesign of Shimo Docs' WebSocket gateway—from a Node.js/Socket.IO 1.0 version to a Go‑based 2.0 architecture—covering handshake degradation, TLS memory savings, SnowFlake SocketID generation, Redis‑based session broadcasting, heartbeat tuning, custom Kafka headers, object pooling, MessagePack compression, extensive performance testing, and the resulting stability and scalability improvements for handling half‑a‑million concurrent connections.
This article describes the evolution from a Node.js‑based WebSocket gateway to a Go‑powered, gRPC‑enabled architecture, detailing the redesign of the gateway, resource‑saving techniques, heartbeat and TLS optimizations, message‑broker choices, extensive performance testing, and the resulting improvements in CPU, memory, and scalability for millions of concurrent connections.
This article details the design, refactoring, and performance testing of a high‑traffic WebSocket gateway for Shimo Docs, covering the evolution from a Node.js Socket.IO version to a Go‑based microservice architecture, TLS memory tuning, socket ID generation, heartbeat handling, custom Kafka headers, and resource‑efficient scaling to half‑a‑million concurrent connections.
This tutorial demonstrates how to implement Redis distributed locks in Java using Jedis, covering lock creation with SETNX, expiration handling, safe unlocking via Lua scripts, and a high‑concurrency simulation of 100,000 users competing for limited stock.
This article explains why Redis achieves extremely high performance by being an in‑memory key‑value store, using compact data structures, a single‑threaded command model with epoll‑based I/O multiplexing, efficient hash tables, progressive rehashing, various persistence options, master‑slave replication, Sentinel monitoring and a sharded Cluster architecture.
This article details the evolution from a Node.js Socket.IO gateway to a Go‑based, gRPC‑enabled WebSocket gateway that supports millions of concurrent connections, covering architecture redesign, TLS handling, socket ID generation, session management, heartbeat optimization, custom Kafka headers, code‑level refinements, and extensive performance testing results.
This article explains three Redis-powered rate‑limiting methods—using SETNX for simple counters, leveraging ZSET for a sliding‑window algorithm, and implementing a token‑bucket scheme with LISTs—providing Java code examples, advantages, and practical considerations for high‑concurrency back‑end services.
The article explains the characteristics of flash‑sale scenarios, presents core design principles such as rate limiting, peak shaving, asynchronous processing and scalability, and details a complete backend and frontend architecture—including Redis‑based queueing and caching—to build a robust, high‑throughput seckill system.
This article explains how to build a Redis‑based message queue for high‑concurrency business scenarios using RPUSH to enqueue tasks and BLPOP to block‑wait for consumption, illustrated with a PHP cancel‑order example and detailed configuration and code snippets.
This article demonstrates how to achieve automatic request idempotency in Spring Boot applications by leveraging Redis for token storage, custom annotations, and interceptor configuration, providing step-by-step code examples for building a Redis service, token service, custom annotation, interceptor, and testing the solution.
This article explains the challenges of mutual exclusion and idempotency in distributed environments, compares thread‑level and process‑level solutions, describes the principles and typical implementations of distributed locks (Zookeeper, Redis, Tair, Cerberus), and introduces GTIS as a reliable idempotency framework.
This article explains the background and challenges of legacy monitoring systems, defines key concepts such as exceptions, problems, alerts and recoveries, introduces critical metrics like MTTA and MTTR, and details the design, architecture, and core implementation of a unified alert convergence service using Redis delay queues.
This article details the design and implementation of a Hystrix‑style circuit breaker for PHP, covering circular and fixed bucket counters, distributed time synchronization, dynamic Apollo configuration, event handling, monitoring tools, single‑node versus cluster approaches, key‑length handling, storage abstraction, and performance testing results.
This article provides a systematic, step‑by‑step methodology for diagnosing Redis latency spikes, covering baseline performance testing, slow‑log analysis, high‑complexity commands, big‑key handling, expiration patterns, memory limits, fork overhead, huge‑page settings, AOF configurations, CPU binding, swap usage, memory fragmentation, network saturation, and practical monitoring tips.
The article thoroughly examines Redis’s high‑performance architecture, detailing the evolution from blocking to non‑blocking I/O, the Reactor pattern’s single‑ and multi‑reactor models, Redis’s I/O multiplexing thread design, and how its hybrid single‑thread core with auxiliary I/O threads mitigates bottlenecks under heavy traffic.
This article explains how Redis, an in‑memory key‑value store, ensures data durability through two persistence methods—RDB snapshotting and AOF command logging—detailing their commands, file structures, configuration options, performance trade‑offs, and rewrite processes.
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.
