This guide explains the need for Redis clustering to achieve high availability, walks through Redis 3.0's decentralized cluster configuration, shows how to modify redis.conf, start multiple nodes, create the cluster, use hash slots, handle failures, and connect via Java Jedis, highlighting both advantages and limitations.
This comprehensive guide walks you through Redis production deployment, persistence strategies, performance tuning, security hardening, real‑world case studies, and failure recovery, helping you prevent common pitfalls and keep your cache layer reliable and fast.
This article explains how Redis achieves high concurrency through non‑blocking I/O, an event‑driven reactor model, efficient I/O multiplexing, in‑memory data structures, and cluster sharding to support millions of simultaneous connections.
In Redis's single‑threaded model, commands with O(n) or higher complexity—such as KEYS, HGETALL, LRANGE, SMEMBERS, and DEL on large keys—can block the server during traffic spikes, but using incremental scans, key splitting, and async deletion can eliminate the risk and keep services responsive.
This guide explains how to create a dynamic IP blacklist that blocks malicious crawlers or users by rejecting requests from listed IPs, supports configurable expiration, and is implemented using Nginx (OpenResty), Lua scripts, and Redis for shared, lightweight, and scalable protection.
This article outlines Xiaohongshu's 2024 autumn recruitment details, salary ranges for different offer tiers, work‑schedule changes, and provides in‑depth answers to common backend interview questions covering Redis performance, HTTP vs RPC, virtual memory layout, Go's GMP model, coroutine advantages, C++ class size, diamond inheritance, static variables, core‑dump analysis, and a median‑finding algorithm challenge.
This article recounts the 2005 emergence of Git and Mercurial, explains how Ruby on Rails enthusiasts transformed Git into GitHub, and shows how their advocacy later accelerated Redis adoption, while also highlighting other tools that rose from the same community influence.
This article explains how to implement a memory‑efficient sign‑in feature and continuous‑sign‑in statistics using Redis BitMap, covering basic commands, Spring Boot integration, key design, code examples, and advanced use cases such as cache‑penetration mitigation, providing step‑by‑step guidance for backend developers.
This article explains how to use Redis Sorted Sets for efficient pagination, leverages Hashes and HSCAN for multi‑condition fuzzy queries, and combines both techniques with performance‑optimizing strategies such as expiration and real‑time updates.
This guide walks you through installing and configuring Prometheus and Grafana, comparing Prometheus with Zabbix, adding exporters for system metrics, MySQL, RabbitMQ, Redis and TiDB, setting up dashboards, plugins, and email alerts to create a comprehensive monitoring solution.
This article explains how to build a dynamic IP blacklist using Nginx, Lua scripts, and Redis, covering the problem definition, environment setup, design choices, Nginx configuration, Lua script implementation, testing, and extensions such as use‑case scenarios and advanced features.
This guide explains how to create a dynamic IP blacklist that blocks malicious crawlers and users by configuring Nginx with Lua scripts and a Redis store, covering requirements, environment setup, design options, configuration files, Lua code, summary of benefits, use cases, and advanced extensions.
This article analyzes current system performance bottlenecks, compares hard‑rate‑limiting and flexible queuing strategies, and presents a non‑intrusive traffic‑control solution built with OpenResty+Lua and Redis that offers zero‑code changes, high performance, scalability, and real‑time visual feedback for high‑concurrency scenarios.
This article compiles a comprehensive Java interview guide covering object‑oriented fundamentals, method overloading vs overriding, core collection implementations, Spring bean lifecycle, composite index usage, process/thread/coroutine distinctions, Linux IPC methods, design‑pattern principles, Redis roles and data types, relational vs NoSQL trade‑offs, QR‑code login design, and a classic 15‑minute brain teaser.
This article explains why tracking user online duration matters across IM, e‑learning, gaming, and SaaS platforms, and provides a detailed backend design using a heartbeat‑Redis cache, login/logout logging, and a hybrid approach, complete with data models and Java implementation examples.
This article explains why traditional load‑balancing methods fall short for large language model services and introduces Higress AI Gateway's three specialized algorithms—global minimum‑request, prefix‑matching, and GPU‑aware load balancing—detailing their design, Redis‑based implementation, deployment steps, and performance gains.
This guide explains how to replace traditional session‑based captcha authentication with a Redis‑backed, token‑driven solution using the high‑performance PHP Webman framework and the tinywan/captcha plugin, covering architecture, generation and verification flows, installation steps, and code examples.
This guide explains how to create a dynamic IP blacklist using Nginx, Lua scripts, and Redis, covering requirements, environment setup, design options, Nginx configuration, Lua implementation, summary of benefits, and possible extensions for advanced security scenarios.
This article examines the three classic Redis caching problems—cache penetration, cache avalanche, and cache breakdown—illustrates real‑world incidents that caused system outages, and provides comprehensive mitigation techniques such as Bloom filters, null‑value caching, random expiration, multi‑level caches, logical expiration, and distributed locks, along with monitoring and disaster‑recovery practices.
Explore comprehensive Redis data type operations—including strings, hashes, lists, sets, and sorted sets—through detailed command examples, usage scenarios, and practical tips, while also learning how to manage keys, expiration, and messaging queue concepts for effective in‑memory data handling.
This guide outlines key factors that affect PHP web application performance and provides practical steps—including PHP environment tuning, disabling debug mode, caching strategies, session and database optimizations, Composer autoload improvements, and offline processing—to significantly speed up your app.
This article examines the limitations of traditional database‑based ID generation, compares common distributed ID solutions such as UUID, Snowflake, Baidu uid‑generator and Meituan Leaf, and presents a custom strictly incremental ID scheme that combines database segment allocation, Redis caching, and Nacos‑controlled mode switching.
This article examines the challenges of distributed ID generation, compares common solutions like UUID and Snowflake, and presents a custom approach that combines MySQL segment tables, Redis caching, and Nacos switches to achieve high‑performance, strictly incremental IDs with automatic failover.
This article provides a comprehensive guide to Redis Sentinel, covering its purpose, architecture, monitoring functions, discovery mechanisms, failover process, leader election, configuration options, and practical commands for achieving reliable high‑availability in Redis deployments.
This article introduces Easy-Cache, a Spring‑AOP based caching framework that eliminates repetitive cache code by offering annotation‑driven operations, multi‑level Redis and local caches, dynamic upgrade/downgrade, elastic expiration, and Lua‑script‑backed consistency mechanisms for high‑availability distributed systems.
This article provides a systematic, step‑by‑step methodology for identifying the root causes of Redis performance degradation—including big keys, slow queries, expiration spikes, memory limits, fork latency, AOF flushing, memory fragmentation, swap usage, huge pages, and CPU binding—and offers immediate mitigation tactics as well as long‑term architectural solutions to restore and maintain high throughput.
This comprehensive guide explains Redis Streams—its data model, entry IDs, range queries, blocking reads, consumer groups, pending message handling, trimming, persistence, and performance characteristics—providing practical commands, examples, and best‑practice tips for building reliable streaming applications.
This article provides a comprehensive guide to Redisson's distributed lock implementation, covering its architecture, comparison with Jedis and Lettuce, basic lock creation, Lua scripts for atomic operations, reentrant lock handling, watchdog-based lock renewal, RLock usage, and the design of fair locks using Redis data structures.
This article explains how Redis and Zookeeper implement distributed locks, compares their performance, consistency, and reliability, and provides guidance on choosing the appropriate lock mechanism for different backend scenarios.
This article walks through the design, pitfalls, and step‑by‑step implementation of a token‑bucket rate‑limiting middleware for the Webman PHP framework, highlighting the need for atomic Redis operations and showing how a Lua script resolves concurrency issues in distributed environments.
Learn how to build a secure authentication system in Spring Boot 3 that restricts each user to a single active session, stores tokens in Redis, and implements automatic JWT token refresh, with detailed code examples and step‑by‑step explanations.
This guide walks you through installing RedisInsight, configuring its environment variables, deploying it on Kubernetes, and using its GUI to monitor Redis memory, connections, and performance, while also covering the prerequisite Redis server setup and essential command‑line operations.
This article explains the three‑stage execution flow of a Redis command—connection establishment, command processing, and result return—detailing how the single‑threaded reactor pattern drives event handling, how commands are parsed and dispatched, and how the output is sent back, with code snippets and a comparison to Netty’s multithreaded reactor.
To retrieve up to 100 000 items from a pool of tens of millions, the article compares multi‑threaded ClickHouse pagination, Elasticsearch scroll‑scan deep paging, a combined ES‑HBase approach, and RediSearch + RedisJSON, detailing design, implementation code, performance benchmarks, and trade‑offs.
This comprehensive guide walks you through Redis cluster architecture, deployment, enterprise‑grade configuration management, logging, monitoring, queue handling, performance tuning, and fault‑tolerance practices, providing step‑by‑step instructions, scripts, and best‑practice recommendations to quickly resolve the majority of production problems.
This article breaks down the massive‑scale challenge of calculating mutual friends for hundreds of millions of users, analyzes data‑size, latency, and memory constraints, and presents three Redis‑based solutions—basic Set, bitmap, and a sharded architecture—complete with code snippets, performance numbers, and practical trade‑offs.
This article explores four common rate‑limiting algorithms—fixed window, sliding window, leaky bucket, and token bucket—explains their core principles, shows Java and Redis implementations, discusses real‑world production cases, and provides practical tips for avoiding pitfalls and optimizing performance.
This article provides comprehensive interview guidance and technical deep‑dives covering Java self‑introduction, the B‑T‑A‑R project‑highlight model, differences between abstract classes and interfaces, varargs usage, database index pros and cons, Redis pipeline vs Lua scripting, cache‑breakdown mitigation, distributed session consistency, and memory‑efficient Excel export techniques.
The article reveals REDstar algorithm and developer salary packages, explains why Xiaohongshu’s work schedule changed, and then provides detailed Java interview questions covering MySQL indexes, composite indexes, Java primitive types, boxing/unboxing, ReentrantLock vs synchronized, Redis usage, common commands, distributed locking, and the benefits of RocketMQ, all illustrated with code snippets and diagrams.
This article explains how to protect time‑consuming business operations using a Redis‑based distributed lock implemented with a custom annotation, Spring AOP interception, automatic lock renewal via a scheduled executor, and proper lock release, ensuring data consistency across concurrent requests.
This article explains the Bloom filter data structure, its hash‑based design and false‑positive behavior, then demonstrates practical implementations using Java BitSet, Guava, and Redisson, covering initialization, configuration, usage tips, and performance considerations for Redis bitmap storage.
This article explains how to implement a precise sliding‑window rate‑limiting algorithm using Redis Sorted Sets, detailing the problem scenario, the algorithm steps, Lua script implementation, Java integration, and practical extensions for high‑performance backend services.
This article explains how to use segmented (sharded) locks and Redis‑based routing strategies to parallelize inventory deduction and order creation, dramatically increasing orders processed per second while maintaining atomicity and fault tolerance.
This article explains why Redis, a single‑threaded in‑memory database, can become blocked, covering five common culprits such as blocking commands, big keys, database flushes, synchronous AOF writes, and the SAVE command, and offers guidance on preventing performance stalls.
This guide walks operations engineers through installing Redis, configuring a six‑node cluster, applying memory and system‑level performance tweaks, setting up Sentinel high‑availability, and implementing Python‑based monitoring and automated recovery scripts, providing a comprehensive, hands‑on approach to building a robust Redis service.
Learn how to design and implement a Redis-based distributed lock in Java using custom annotations, AOP interception, and a scheduled executor to automatically extend lock expiration, ensuring safe concurrent access to critical resources while handling timeouts, retries, and thread interruptions.
This article explores various techniques for implementing delayed tasks in Java, comparing Quartz database polling, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets, and RabbitMQ delayed queues, detailing their implementations, advantages, drawbacks, and practical code examples for handling order timeouts.
This article explains why single‑node Redis can become a single point of failure, compares Redis Sentinel and Redis Cluster deployment options, provides step‑by‑step Docker deployment scripts, details Sentinel’s inner workings, demonstrates failover verification, and shares best‑practice recommendations for production environments.
The article shares a detailed SF interview experience, covering typical Java interview questions such as self‑introduction, challenging projects, learning paths, abstract class vs interface, HashMap vs Hashtable, insertion steps, red‑black and B+ trees, MySQL and Redis indexing choices, large‑table optimization, JVM memory model, and the purpose of the Survivor space.
A week‑long API freeze in a sandbox environment was traced to a misconfigured Redis connection pool in a Spring Java application, where threads waited indefinitely for a Jedis resource, and the fix involved setting proper pool timeouts, using RedisCallback for scans, and correctly releasing connections.
This comprehensive guide walks you through installing Redis on a single server using source compilation and Docker, configuring persistence, memory management, backups, disaster recovery, and systemd service setup, ensuring a production‑ready Redis instance that can handle over 10,000 QPS.
This tutorial walks Java developers through using Redis in Spring Boot projects, covering the essential spring-boot-starter-data-redis dependency, RedisTemplate basics, the underlying RedisConnectionFactory design, custom connection configurations for single‑node and sentinel modes, and seamless integration of the Redisson client for advanced distributed features.
This article explains what debounce means for web APIs, identifies which endpoints need it, describes how to detect duplicate requests, and provides complete Java implementations using shared Redis caches and Redisson distributed locks with code examples and key generation strategies.
This article analyzes a production‑line data‑distribution issue where parallel processing and rule‑based assignment cause some employees to receive no tasks, explains why simply increasing batch size fails, and presents a Redis‑counter solution that balances efficiency with fair workload distribution.
This article explains Redis' deployment models, core components, and the event‑driven engine that powers command processing, detailing the flow from client connection through the reactor loop, command parsing, execution, and response delivery with code examples and diagrams.
This guide walks you through the realities of joining state‑owned enterprises, offers practical tips for Java backend interview preparation—including self‑introduction, project presentation, database choices, Redis eviction policies, common design patterns, singleton usage, thread‑safety concepts, and commands to terminate Java processes on Linux, macOS, and Windows.
This article explains why the KEYS command is unsafe for large Redis keyspaces, introduces the SCAN command and multithreaded scanning techniques, compares performance, and offers alternative counting strategies to reliably count hundreds of millions of keys.
This article explains why traditional polling fails for large‑scale delayed tasks, compares built‑in Java, RocketMQ, and RabbitMQ delay queues, and provides a detailed Redis‑based design with architecture diagrams, message structures, and a 2.0 version that uses real‑time locking for low‑latency delivery.
This article explains how to implement distributed locks using Redis, covering basic SETNX/EXPIRE techniques, common pitfalls, atomic Lua scripts, the RedLock algorithm, and practical Redisson usage, while providing Java code examples and best‑practice recommendations.
This article examines the open‑source memory cache Dragonfly, its claim of being the world’s fastest Redis‑compatible system, the Redis team’s detailed response and benchmark methodology, and presents comprehensive performance comparisons that show Redis often outperforms Dragonfly across various workloads and configurations.
Redis bitmap commands enable efficient bit‑level storage and fast counting, and this article explains the core concepts, key commands like BITSET, BITGET, BITCOUNT, and provides a complete PHP example that tracks user sign‑ins and calculates daily totals using Predis.
This article explains Redis 6.0's multithreaded I/O feature, covering its background, configuration parameters, execution flow, source code analysis, performance benchmarking against single‑threaded mode, identified limitations, and a brief comparison with Valkey 8.0's advanced I/O design.
This article explains why multiple independent login systems hurt user experience and security, reviews traditional session mechanisms and their limitations in clustered environments, and then presents two session‑sharing strategies and a complete CAS‑based SSO solution with Java code examples.
This article explains why the KEYS * command is dangerous for large Redis deployments and presents several practical alternatives—including SCAN, multithreaded SCAN, cluster‑wide parallel scans, built‑in counters, and real‑time incremental counting—along with code samples, performance comparisons, and guidance on choosing the right solution.
This tutorial explains how to integrate Redis caching into a FastAPI application, covering installation, connection handling, cache expiration, testing, cache clearing, and best‑practice considerations to dramatically improve API response times and scalability.
The article shares a personal experience of TP-Link's early campus recruitment and salary expectations, then provides a comprehensive Java backend interview guide covering class‑loader delegation, JVM memory layout, garbage‑collector types, synchronized lock mechanics, and common Redis cache pitfalls with practical solutions.
Explore essential Redis Cluster interview questions covering slot count, hashing mechanisms, use cases, configuration options, hash slots, hash tags, node ports, and consistency model, providing concise answers that help candidates master the core concepts and excel in technical interviews.
This article explains what Redis hotspot keys are, the performance and stability issues they cause, common causes, how to monitor and identify them, and practical mitigation strategies such as cluster scaling, key sharding, and multi‑level caching.
Redis, an in‑memory high‑performance data store, serves as a popular secondary cache; this article explains its key features, data structures, persistence options, and presents a step‑by‑step Java workflow—including client creation, request sending, result handling, and connection cleanup—to help test engineers design effective performance tests.
This article examines common pitfalls of using single‑machine synchronization and basic SETNX locks for high‑concurrency stock‑deduction scenarios, demonstrates step‑by‑step improvements—including lock expiration and Redisson’s Lua‑based implementation—and discusses trade‑offs between Redis and Zookeeper for distributed locking.
This article explains Redisson's various distributed lock mechanisms—including watchdog, reentrant lock, multi‑lock, read‑write lock, semaphore, RedLock, and CountDownLatch—detailing their principles, usage patterns, code examples, and best‑practice recommendations for robust backend concurrency control.
This article explains MaShang Cloud's RDS high‑availability design, detailing the distributed sentinel monitoring system, proxy layer, multi‑AZ disaster‑recovery strategies, and real‑world case studies that demonstrate how MySQL and Redis services maintain continuous, consistent access with minimal RTO and RPO.
The article explains how Baidu Cloud Redis's Data Flashback feature combines RDB snapshots with timestamped AOF logs to provide fast, space‑efficient, point‑in‑time data recovery, overcoming the limitations of native Redis persistence in high‑traffic scenarios.
This article explains how to implement request debouncing in Java backend services using Redis and Redisson, covering the concept, interface types needing debouncing, duplicate request detection, shared cache and distributed lock solutions, with complete code examples and testing results.
This guide walks you through creating a full-featured QR code login demo using Spring Boot, WebSocket, and Redis, covering backend services, frontend pages, project structure, code snippets, deployment steps, and security best practices for a seamless login experience.
This article explains why per‑minute API call counting is essential for performance bottleneck detection, capacity planning, security alerts and billing, and presents five concrete Java‑based implementations—including a fixed‑window counter, a sliding‑window counter, AOP‑based transparent monitoring, a Redis time‑series solution, and Micrometer‑Prometheus integration—along with a hybrid architecture, performance benchmarks, and practical capacity‑planning advice.
The author recounts fixing a complex Redis Vector Sets bug, explores how human creativity outperforms LLMs in devising efficient data‑consistency checks, and shares experimental ideas—including XOR accumulators and MurmurHash—to detect non‑mutual links in large HNSW graphs.
This article explains how Baidu Intelligent Cloud Redis introduces a hybrid RDB‑AOF persistence model with built‑in timestamps, enabling fast, storage‑efficient point‑in‑time recovery—addressing the limitations of native Redis RDB snapshots and AOF logs for critical game and e‑commerce workloads.
The article analyzes a Meituan interview question about caching 10 million MySQL rows when Redis can store only 200 thousand rows, presenting a five‑step three‑tier cache architecture that separates cold and hot data, selects appropriate eviction policies, uses proactive hotspot detection, adds multi‑level defense, and employs both scheduled and real‑time pre‑heating, with performance numbers showing an 85% hit rate and 100 ms latency.
This guide explains how to set up and run Locust load tests for WebSocket connections and Redis interactions in Python, including client implementations, heartbeat simulation, and practical tips for resource management and concurrency control.
This article explains how to achieve API idempotency by having clients send a short‑lived unique serial number, storing it as a Redis key with SETNX and an expiration, and handling the Redis response to process or reject duplicate requests.
Redis 8 has been released under the OSI‑approved AGPLv3 license, reversing its 2024 SSPL shift, and brings up to 87% faster command execution, double the throughput, and integrated modules like JSON, TimeSeries, and the new Vector Sets data type, sparking community debate and competition with Valkey.
This article explains how to use Redis Sorted Sets and Hashes to achieve efficient pagination, fuzzy multi‑condition queries, and their combination, while also discussing performance‑optimisation strategies such as temporary ZSet expiration and data‑freshness handling, before concluding with a brief promotional segment.
This article provides a comprehensive tutorial on RedisInsight, covering its features, step‑by‑step physical and Kubernetes installation, environment variable setup, service startup, and basic usage together with Redis server configuration, illustrated with code snippets and screenshots.
This article shares ten practical cache governance rules—from avoiding large keys and setting proper TTLs to using distributed locks and final consistency strategies—illustrated with real‑world Java examples, code snippets, and diagrams to help backend developers design reliable, high‑performance caching solutions.
During a major promotion a huge activity generated an oversized Redis cache key that caused cache‑penetration, saturated network bandwidth, and triggered a cascade of service failures, prompting a detailed root‑cause analysis and a set of mitigation and prevention measures.
Redis clusters use two redirection commands—MOVED for permanently migrated hash slots and ASK for temporary redirects during slot migration—explaining their trigger conditions, typical scenarios, and step-by-step client interaction examples, including sample CLI output.
This article explains why API debounce is needed in web back‑ends, identifies the types of endpoints that require it, outlines how to detect duplicate requests, and provides two concrete distributed solutions—shared Redis cache and Redisson lock—complete with annotation design, key generation logic, and full Java code examples.
This article analyzes the challenges of e‑commerce flash‑sale spikes and presents four proven architectural patterns—pressure distribution, Redis + MQ, Inventory Hint, and their combined use—detailing their principles, Lua scripts, transaction messaging, and practical trade‑offs for building resilient, high‑throughput systems.
Redis is ubiquitous in Java development for caching, ranking, and distributed locks, but its transaction model differs from traditional databases; this article explains Redis transaction fundamentals, core commands (MULTI, EXEC, DISCARD, WATCH), common pitfalls, best practices, and interview FAQs to help developers avoid mistakes.
This article explains the PFAIL (possible fail) and FAIL (failed) states in Redis clusters, describes the state transition process, demonstrates node failure and automatic failover with command‑line examples, and provides practical insights into cluster health monitoring and recovery.
Redis 8.0, released on May 1 2025, introduces a major license shift to AGPL‑v3, adds eight native data structures—including vector sets, JSON, and time‑series—enhances the query engine with up to 16× performance gains, improves scalability, security, and cloud‑native support, and provides extensive code examples for AI and real‑time analytics.
This article explains how to prevent duplicate order submissions during high‑traffic e‑commerce events by using a server‑generated anti‑duplicate token stored in Redis, detailing the token acquisition, validation flow, and handling of repeated requests to ensure inventory integrity and accurate financial reconciliation.
This article explains how to extract AOP annotation code, implements a Redis-based rate limiter using Redisson in Java, analyzes the underlying Lua script, and extends the utility to support automatic expiration of the limiter, providing complete code examples and detailed explanations.
This guide demonstrates how to protect a Spring Boot service from malicious requests by creating a custom interceptor that tracks URL‑IP request counts, uses Redis for distributed locking, and disables offending IPs after a configurable threshold, with full code examples and configuration steps.
This guide walks you through installing software on CentOS using three primary methods—source/tarball compilation, RPM packages, and Yum—demonstrating each approach with real‑world examples such as Redis, RabbitMQ, and Nginx, and covering essential concepts, commands, and configuration steps.
This guide explains the principles of MySQL master‑slave replication, shows how to configure and verify replication, provides Dockerfiles and docker‑compose files for MySQL and Redis clusters, and demonstrates testing each cluster step by step.
The article examines how e‑commerce platforms implement order auto‑closure using delayed tasks, compares methods such as message‑queue delayed delivery, Redisson delay queue, Redis expiration listening, RabbitMQ dead‑letter queues and time wheels, and recommends reliable approaches while warning against unsafe practices.
This article explains how to import 1 billion 1 KB log records stored in HDFS or S3 into MySQL by analyzing single‑table limits, using batch inserts, choosing storage engines, sharding, optimizing file‑reading methods, and coordinating distributed tasks with Redis, Redisson, and Zookeeper to ensure ordered, reliable, and high‑throughput data loading.
This article explains how to manually migrate a hash slot in a Redis cluster by checking cluster status, setting importing and migrating slots, retrieving keys, using the MIGRATE command, and updating slot assignments across nodes, with detailed command examples and explanations.
