This article walks through a production incident where a Redis Cluster pipeline caused Dubbo threads to block and eventually deadlock, detailing the root‑cause analysis, code inspection, and verification steps using jstack, jmap, and MAT to confirm the deadlock and propose fixes.
This guide walks through installing the open‑source JumpServer bastion host on a Kubernetes cluster using Helm, configuring external MySQL and Redis databases, customizing Helm values, and exposing the web UI through an Istio gateway for secure access.
This article explains what distributed locks are, outlines their key properties, classifies implementation approaches, and provides detailed walkthroughs of MySQL, Redis, Etcd, and ZooKeeper based locks—including code examples, trade‑offs, and best‑practice recommendations.
The article details a step‑by‑step investigation and optimization of a Java backend service that initially delivered only 50 requests per second under load, covering profiling, slow‑SQL fixes, thread‑pool tuning, JVM memory adjustments, and Spring bean creation overhead to approach the target 500 req/s.
This article provides a comprehensive overview of Redis, covering its architecture, key features, data types, caching use cases, common pitfalls such as consistency, avalanche, penetration and breakdown, as well as performance reasons, eviction policies, persistence options, replication, and Sentinel high‑availability mechanisms.
This article walks through the full engineering process of importing a billion 1 KB log records into MySQL, covering data size calculations, B‑tree index limits, batch‑insert strategies, storage‑engine trade‑offs, fast file‑reading techniques, task coordination with Redis and Redisson, and distributed‑lock design using Zookeeper.
This article explains Redis persistence options, detailing how the Append‑Only File (AOF) and snapshot (RDB) mechanisms work, their write‑back strategies, log rewriting process, and the trade‑offs between performance and reliability for choosing the appropriate approach.
This article explains how to use Redis BitMap to build an efficient sign‑in feature and monthly statistics in a Spring Boot microservice, covering basic BitMap commands, key design, code implementation, testing procedures, and a cache‑penetration mitigation strategy.
The article examines a nightly Redis CPU‑100% alert caused by massive simultaneous key expirations, analyzes the active and slow expire cycles, and presents two practical redesigns—randomized expiration with real timestamps and time‑suffix keys—that eliminated the spike.
To import one billion 1 KB log records into MySQL efficiently, the article examines data size constraints, B‑tree index limits, batch insertion strategies, storage engine choices, file‑reading techniques, task coordination with Redis, Redisson semaphores, and distributed lock handling to ensure ordered, reliable, high‑throughput loading.
This tutorial walks you through creating mount directories, configuring redis.conf, running a Redis container with Docker, and verifying the setup using redis-cli and a visual client, providing all necessary commands and explanations for a successful deployment.
Hot keys in Redis—high‑frequency accessed keys—can overload the cache and downstream databases, causing crashes; this article explains what hot keys are, why they arise, their risks, how to detect them, and practical mitigation strategies such as scaling clusters, using secondary caches, monitoring commands, and traffic analysis.
This article explains how to use Redis' Sorted Set and Hash structures to achieve efficient pagination, multi‑condition fuzzy queries, and their combination, while also discussing performance optimizations such as expiration handling and data synchronization strategies.
This article details the design and implementation of a self‑managed Redis KV cache system spanning tens of terabytes, covering its Proxy‑based architecture, ConfigServer high‑availability via Raft, Redis‑Proxy slot routing, async‑fork optimizations, data migration strategies, and a comprehensive automation platform for deployment, scaling, monitoring, and stability governance.
This article explains how to design microservice permission control using Apache Shiro, sharing session data via Redis, outlines failed approaches, presents a workable solution with custom cache and session managers, and provides complete code examples for realms, configuration, and login flow.
An in‑depth, timeline‑driven investigation of a production Redis memory leak revealed that the custom 3.2.8 build’s getKeysInSlot function failed to free a temporary key‑array after traversing the radix‑tree, causing hundreds of megabytes of leaked SDS strings, which was fixed by adding a single free call and highlighted the need for functional code reviews and early leak detection.
This comprehensive guide walks you through setting up Spring Security in a Spring Boot project, configuring password encoding, implementing JWT-based authentication, building custom login and logout endpoints, managing user details with MyBatis Plus, and applying role‑based access control with custom permission handlers, all illustrated with complete code examples.
Redis creator antirez released Smallchat, a compact open‑source C chat server of about 200‑300 lines, illustrating multiplexed I/O with select, global state handling, and client management, making it an ideal hands‑on example for C network‑programming beginners.
This article explains why Redis may become slower, covering benchmark testing, high‑complexity commands, big keys, concentrated expirations, memory limits, fork overhead, huge pages, AOF settings, CPU binding, swap usage, memory fragmentation, and lazy‑free mechanisms, and provides practical optimization steps.
This article explains how Redis can be used for distributed locks, rate limiting, various message‑queue patterns, delayed queues, distributed sessions and complex business scenarios, while also discussing the limitations of using Redis as a message queue and recommending dedicated solutions like RocketMQ or Kafka.
This article explains how to implement a memory-efficient sign-in system and continuous-sign-in statistics using Redis BitMap, covering basic BitMap commands, Spring Boot integration, core source code, and a BitMap-based approach to mitigate cache-penetration attacks.
This guide explains how to build a dynamic IP blacklist using Nginx, Lua, and Redis, covering installation of LuaJIT, compiling Nginx with required modules, configuring Redis, writing Lua access‑limit scripts, and verifying that frequent requests are automatically blocked for a set period.
Redis Sorted Sets, powered by skip lists, provide O(log n) operations for ranking and range queries; this article explains their internal structure, core commands, and demonstrates how to implement a real‑time leaderboard in Spring Boot using Redis, complete with configuration, entity design, and service methods.
This article analyzes a coupon‑claiming race condition that caused stock to become negative under load and presents four solutions—including Java synchronized blocks, SQL conditional updates, Redis SETNX locks, and Redisson client locks—to reliably prevent over‑issuance in backend systems.
This article explains how to achieve conditional fuzzy queries and pagination in Redis by leveraging Sorted Sets and Hashes, detailing command usage, data modeling, combination strategies, and performance optimizations such as expiration and real‑time updates.
This article explains how to implement cross‑platform caching in PHP using both file‑based storage and Redis, providing complete code examples and detailing the functions involved to ensure compatibility, performance, and proper cache expiration handling.
Redis‑On‑Rocks (ROR) extends the Redis codebase with RocksDB to provide cold‑hot data tiering, reducing memory costs by about two‑thirds while maintaining low latency and high throughput, and the article details its design, implementation, benchmarking against Redis‑on‑Flash, and production experience.
The article explains what constitutes a big key in Redis, why they arise, the performance and blocking issues they cause, and provides multiple practical methods—including built‑in commands, SCAN, MEMORY USAGE, RDB analysis tools, and cloud services—to detect and mitigate big keys effectively.
This article explains what Redis hotkeys are, the performance and replication problems they cause, various techniques for detecting them—including client statistics, MONITOR, the HOTKEYS command, and TCP packet capture—and practical mitigation approaches such as sharding, multi‑level caching, and monitoring optimization.
To achieve disaster-recovery and cross-data-center resilience, Didi progressed from a simple proxy double-write scheme to a sophisticated MQ-free multi-active Redis design that uses a dedicated syncer, shard-based loop prevention, op-id replay protection, conflict detection, and incremental AOF durability, ensuring low latency, no data loss, and consistent availability.
This article details the design and implementation of a Java‑based flash‑sale (Seckill) system using SpringBoot, Redis, RabbitMQ, and related technologies, covering architecture, security, caching, asynchronous processing, oversell prevention, and rate‑limiting techniques.
The article walks through a Java backend design that replaces RedisTemplate with a Redisson‑backed CacheManager, explains the PlusSpringCacheManager class, its configuration bean, key syntax, usage examples, and compares Redisson’s cache features to traditional RedisTemplate approaches.
This comprehensive guide covers essential programming fundamentals—including Python memory management, metaclasses, decorators, multithreading, data structures, algorithmic techniques, database concepts such as ACID, indexing, and transaction isolation, Redis operations, Linux memory handling, networking protocols, Docker/Kubernetes commands, and core testing methodologies—providing clear explanations and practical code examples.
This article explains how Redis evolved from a simple cache to a high‑performance distributed data store, covering its architecture, persistence models, scalability, high‑availability features, complex data structures, and the trade‑offs of using it as a primary database versus a traditional relational system.
This step‑by‑step guide shows how to download, configure, and launch SkyWalking with Spring Boot, connect it to Elasticsearch, instrument a sample service and Redis calls, and view real‑time monitoring data through the SkyWalking UI and Kibana.
The incident showed that Redis hashes encoded as ziplist incur O(N) HEXISTS latency, causing high CPU on hot keys, while hashtable‑encoded hashes remain O(1); adjusting hash‑max‑ziplist settings or redesigning hot‑key patterns can convert to faster, though more memory‑hungry, hashtable encoding.
This article explains various PHP caching techniques—including file‑system, memory (Memcache and Redis), and framework (Laravel) caches—providing code examples and configuration steps to reduce database load, speed up page rendering, and enhance overall user experience.
This article explains why traditional local locks fail in distributed systems, surveys common distributed‑lock approaches, and provides a step‑by‑step guide to building a robust Redis‑based lock in Java—including expiration handling, UUID safety, Lua‑script atomicity, re‑entrancy, automatic renewal, and the RedLock algorithm—while comparing its performance against plain local locks.
This article examines the benefits and drawbacks of implementing caching in PHP backend development, illustrating how caching can boost page load speed, reduce database load, and improve performance, while also discussing cache expiration, data consistency, and memory usage, accompanied by practical code examples.
This article explains how to integrate Lua scripts into Spring Boot projects for Redis, covering Lua fundamentals, performance benefits, practical use cases, step‑by‑step implementation with code examples, error handling, security considerations, and best‑practice recommendations for backend developers.
This article explains how Redis data structures such as SortedSet, Hash, and List can efficiently store and retrieve live‑stream room rankings, count‑type data, timeline events, and multi‑device IM message synchronization, with concrete command examples and implementation steps.
This article explains how Redis implements geospatial indexing with GEOADD and GEORADIUS commands, walks through their source‑code implementations, describes the underlying geohash calculations and nine‑cell grid search strategy, and derives the O(N + log M) time complexity for nearby‑people queries.
This article analyzes the constraints of loading one billion 1 KB log records from distributed storage into MySQL, evaluates single‑table limits, proposes batch‑insert, sharding, storage‑engine, file‑reading, and distributed‑task coordination techniques to achieve high‑speed, ordered, and reliable data ingestion.
This article examines why local locks fail in distributed micro‑service environments, introduces Redis‑based distributed locking, walks through five incremental lock designs—from a simple SETNX implementation to a Lua‑script atomic solution—highlighting each scheme's trade‑offs, code examples, and practical pitfalls.
This article explains why oversized Redis keys (BigKeys) cause data skew, network blockage, slow queries, and high CPU load, shows how to detect them with redis-cli and other tools, and provides practical strategies—including lazy deletion, key splitting, and preventive design—to mitigate their impact on production systems.
This article explains Spring Boot's auto‑configuration mechanism, covering how @EnableAutoConfiguration loads configuration classes, the role of @AutoConfigurationPackage and @Import, the processing of spring.factories and metadata files, and how the main application class is registered in the IoC container.
The article explains how Redis’s rich data structures and persistence options enable it to serve not only as a distributed cache but also as a primary store for user profiles, counters, leaderboards, relationships, active‑user tracking, distributed locks, rate limiting, messaging, geospatial queries, and more, while also discussing high‑availability and hot‑cold data challenges.
The article explains why multiple independent systems hurt user experience, reviews traditional session and cookie based authentication, discusses session sharing problems in clustered environments, and presents centralized Redis storage and CAS‑based single sign‑on solutions with code examples and a comparison to OAuth2.
This article explains what constitutes a Redis BigKey, why oversized keys degrade performance through data skew, network blocking, slow queries and CPU pressure, and provides practical detection methods, open‑source tooling, and mitigation techniques such as lazy‑free deletion, incremental scans, and key sharding.
This article introduces Redisson, a Java framework built on Redis for distributed systems, detailing its extensive features such as distributed objects, locks, rate limiters, and task scheduling, and provides step‑by‑step guidance on integrating Redisson’s distributed lock into Spring Boot applications with code examples.
This article explains why Redis, despite being described as single‑threaded, achieves extremely high performance by using a single thread for network I/O and command execution, avoiding multithreading overhead, and leveraging efficient in‑memory data structures together with an event‑driven multiplexing I/O model.
This article walks through a real‑world R2M (Redis‑like) cache alert, detailing the email notification, large‑key analysis, code inspection, root‑cause identification, and both immediate and long‑term solutions that reduced cache usage by over 97% and prevented future incidents.
This article compares delayed and scheduled tasks, analyzes several implementation approaches—including database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis ZSET and key‑space notifications, and RabbitMQ delayed queues—provides code examples, and discusses the advantages and drawbacks of each method for handling order timeout scenarios in payment systems.
The article details a week‑long investigation of a sandbox environment where Spring Boot APIs became unresponsive due to Redis connection pool blocking, describing the use of system tools, JVM thread analysis, and code inspection to identify mis‑configured pool settings and recommending proper connection handling with Spring's RedisTemplate.
This article explains Redis' client‑server request model, introduces the pipeline technique, compares normal and pipelined requests, and provides Spring Boot code examples that demonstrate a three‑fold speed improvement when writing 100,000 keys.
This article provides a comprehensive overview of Redis memory management, detailing how maxmemory limits trigger various eviction policies, explaining the internal freeMemoryIfNeeded algorithm, and describing expiration mechanisms—including active and lazy deletion—and offering guidance on selecting the appropriate eviction strategy for different workloads.
This article examines a Redis 3.x cluster failure caused by a master‑slave switch, detailing how improper Jedis timeout and retry settings triggered a service avalanche, and provides step‑by‑step analysis of the incident, code paths, and recommended configuration adjustments to prevent recurrence.
Redis is exploring a disk‑backed tiered storage architecture, allowing infrequently used data to move from memory to flash and back, a move aimed at reducing costs, improving scalability, and expanding its popularity among developers and gaming applications.
This article explains why Redis cache penetration occurs, how malicious requests can overload databases, and presents two effective mitigation strategies—caching empty objects and employing Bloom filters—detailing their implementation, advantages, and drawbacks.
This article introduces a simplified Seckill (flash‑sale) system built with SpringBoot, detailing its overall architecture, key backend techniques such as distributed sessions, Redis caching, RabbitMQ asynchronous ordering, security measures, oversell prevention, rate limiting, and provides essential code snippets and deployment screenshots.
This article details the design and implementation of a Java-based Seckill (flash‑sale) platform built with SpringBoot, MySQL, Redis, RabbitMQ, and front‑end technologies, covering password hashing, distributed sessions, caching strategies, asynchronous order processing, oversell prevention, rate limiting, and provides code snippets and deployment screenshots.
This article analyzes the design of Vivo's push notification platform, detailing its high‑concurrency requirements, three‑region long‑connection deployment, traffic‑scheduling bypass layer, and layered storage disaster‑recovery solutions, while explaining the trade‑offs and performance metrics behind each architectural decision.
This tutorial walks through creating the directory structure, defining variables, writing task files, and executing an Ansible playbook to automate the installation, compilation, configuration, and startup of Redis on target hosts.
After encountering latency spikes in a service, the article walks through systematic troubleshooting steps—examining module performance, resource metrics, and network latency—followed by detailed Redis diagnostics using metrics, latency commands, and profiling tools, ultimately recommending scaling, rate limiting, and caching strategies to resolve the issue.
The article explains how concurrent database updates can cause Redis cache inconsistency, introduces the delayed double‑delete solution, details each step of the algorithm, provides full Spring Boot AOP implementation code, demonstrates verification with test cases, and shares the complete project repository.
This article explains how Redis can be used to implement distributed locks, outlines common pitfalls such as non‑atomic operations, lock expiration, incorrect unlocking, lack of re‑entrancy and waiting mechanisms, and presents Lua scripts, Java examples, and cluster‑level considerations to mitigate these issues.
This article provides a comprehensive overview of Redis, covering its common application scenarios, detailed comparisons with Memcached, internal data structures, implementation details, and practical usage patterns such as caching, leaderboards, counters, and real‑time analytics for modern backend systems.
A load test revealed Redis latency soaring to 1.2 seconds, and a systematic investigation traced the root cause to mis‑configured JedisPool parameters, leading to excessive connection wait times and churn, which were fixed by aligning pool settings and enabling proper eviction, dramatically improving latency.
The article examines various delayed‑task solutions for order timeout handling in Java, including database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted‑set and key‑space notifications, and RabbitMQ delayed queues, analyzing their implementation steps, advantages, and drawbacks.
This article walks through practical methods for troubleshooting slow service alerts, diagnosing Redis performance bottlenecks, and reproducing issues with local demos and load simulations, offering concrete metrics, command‑line checks, and mitigation strategies such as scaling, rate‑limiting, and pipeline optimization.
The article recounts a developer's painful experience with un‑preheated Redis cache that caused severe latency spikes, then outlines practical cache warm‑up techniques such as gray‑release traffic, database scanning, and ETL‑driven data pipelines to prevent performance degradation and cache snowball effects.
This article explains the fundamentals of finite state machines, demonstrates how to model order lifecycle states and transitions in Java using Spring StateMachine, and provides detailed code examples for persistence, event handling, and advanced error‑handling techniques such as AOP and Redis storage.
This article introduces Redisson, a high‑performance Java Redis client built on Netty, explains its key advantages, and provides a detailed walkthrough of the RedissonLock implementation—including tryLock, blocking lock, unlock logic, associated Lua scripts, and the automatic watchdog renewal mechanism.
The article details how a Dubbo thread‑pool exhaustion incident was traced to a deadlock in Redis Cluster pipeline usage, caused by Jedis pools lacking a borrow timeout, which let threads block indefinitely while holding cross‑node connections, and recommends configuring maxWaitMillis or enlarging the pool to prevent recurrence.
This article explains how Redis uses the maxmemory setting to trigger memory eviction, details the various eviction policies (including LRU and LFU), shows how to query and modify these settings with config commands, and briefly mentions promotional offers for a ChatGPT community.
This tutorial demonstrates how to use Redis' GEO data structure together with Docker, RedisInsight, and a NestJS backend to store location data, perform distance calculations and radius searches, and finally display nearby points on a web map using AMap and Axios.
The article details how a Go service’s 300‑second Redis call timeout was traced to a gateway’s full‑NAT session‑table loss, and explains how targeted retries, proper timeout settings, and rate‑limiting can prevent similar cascading failures in distributed systems.
This article analyzes a MongoDB replication failure caused by missing oplog entries, compares logical initialization repair methods with Redis replication, and provides practical steps—including oplog size adjustment and snapshot techniques—to restore synchronization and prevent similar issues in production environments.
This guide explains how to claim Alibaba Cloud's free ECS credits, use them to spin up multiple machines for hands‑on Redis cluster experiments, and outlines a step‑by‑step learning path from basic Nginx setups to advanced high‑availability and multi‑service architectures.
This article explains key PHP performance optimization strategies—including database query tuning, efficient coding practices, and various caching methods such as Redis and file‑based page caching—providing concrete code examples to improve response time and system stability.
This article explains the fundamentals of finite‑state machines, introduces Spring Statemachine, demonstrates how to model an order lifecycle, configure persistence with in‑memory and Redis stores, and provides complete Java code for enums, configuration, services, controllers, listeners, testing, and exception‑handling improvements.
This article explains why rate limiting is essential for high‑traffic Java services, compares common strategies such as Hystrix, Sentinel, token‑bucket algorithms, and Redis‑based counters, and provides concrete Spring‑Boot code examples for implementing both local and distributed throttling.
This article demonstrates how to implement a captcha‑based login mechanism in a Spring Boot application with a front‑end/back‑end separation, detailing the traditional session‑based approach, the new Redis‑backed token solution, and providing complete code examples for configuration, service, controller, and data objects.
This article explores five common Redis applications—caching, session storage, distributed locking, rate limiting, and leaderboards—explaining how each leverages Redis’s in‑memory speed, atomic commands, and data structures to improve performance, scalability, and reliability of modern web services.
This article explains how to build a distributed task scheduling and dispatch system for PHP microservices by leveraging Redis and RabbitMQ, covering queue creation, node subscription, and providing complete code examples for both tools.
This article explains JWT payload claims, lists standard and custom claims, shows how to generate a token with expiration in Java, and compares single‑token and double‑token renewal strategies—including OAuth 2.0 approaches and Redis‑based storage—to manage token expiration securely.
This article walks through a real‑world e‑commerce scenario where billions of daily browsing events generate over 100K TPS writes, evaluates storage options on reliability, cost, read/write performance and implementation difficulty, and ultimately recommends Tair after detailed analysis of List, Sorted‑Set and Hash structures, code examples, and concurrency controls.
When a Redis‑backed service suddenly experiences high response times, this guide walks through systematic troubleshooting steps—checking server resources, network latency, Redis metrics, slow‑log, memory fragmentation, big keys, and hot keys—culminating in practical solutions such as pipelining, read/write splitting, and cache layering.
The article outlines a systematic three‑step workflow—general service diagnostics, Redis‑specific checks, and reproducible load testing—to pinpoint a hot‑key‑driven CPU bottleneck, then evaluates mitigation options such as read‑write separation, pipelining, and an application‑level cache, ultimately showing the cache’s effectiveness in cutting latency and CPU usage.
This article explains Redis’s five core data object types—strings, lists, hashes, sets, and sorted sets—detailing their encoding schemes, underlying memory structures such as SDS, ziplist, linkedlist, hashtable, and skiplist, and how Redis optimizes storage and access performance.
This guide walks through installing MySQL in Docker, configuring master‑slave replication, verifying synchronization, deploying a Canal server, and integrating it with a Spring Boot application to automatically push database changes into Redis.
This article explains the concept of distributed locks for ensuring data consistency in clustered environments, outlines common implementation approaches, and provides a comprehensive guide to using Redisson in Java—including Maven setup, YAML configuration, core source‑code analysis, Lua scripts for lock and unlock operations, and practical test cases.
This article provides a comprehensive technical walkthrough of Redis, covering its core concepts, data structures, performance tricks, caching pitfalls, persistence options, high‑availability architectures, distributed locking mechanisms, and consistency strategies, all illustrated with concrete examples and code snippets.
This article details the design and implementation of a custom, high‑throughput data migration framework that handles petabyte‑scale transaction data, supports heterogeneous source/target schemas, ensures zero‑downtime operation, and provides robust scheduling, checkpointing, and fault‑tolerance mechanisms.
The article explains how a meeting control system tackled severe storage pressure from high concurrent traffic by introducing a proxy layer, multi‑active disaster‑recovery, identity‑based data isolation, dynamic‑static key separation, multi‑level caching, overload protection, sharding with dual‑write migration, and extensive monitoring to meet 100k QPS and ensure reliability.
This article explains how to design a practical feed‑flow system for enterprises, covering core concepts, feed types, initialization, push‑pull versus pure push strategies, and provides key Java code snippets that illustrate Redis‑based storage and update mechanisms.
This article introduces Redis as a high‑performance in‑memory NoSQL database, explains its rich data structures, core design that makes it fast, key advantages, common use cases such as caching and messaging, and provides step‑by‑step installation and basic command examples.
This article introduces Redis as an open‑source, high‑performance in‑memory key‑value store, explains its rich data structures, underlying implementations, performance advantages, common use cases such as caching and messaging, and provides step‑by‑step installation and basic command examples for Ubuntu systems.
BigKey and HotKey issues in Redis clusters arise when oversized keys block processing or a single key receives excessive requests, causing timeouts, memory overflow, shard collapse, and performance degradation, but can be detected during testing using Redis commands, visual clients, and open‑source analysis tools.
This article investigates why a Spring Boot application using JedisPool experiences high connection‑acquisition latency, analyzes the Evictor logic and mis‑configured pool parameters, and presents a custom configuration solution that stabilizes the pool and eliminates repeated connection creation and destruction.
