This article demonstrates how to create a custom @AccessLimit annotation, implement a Spring Boot interceptor that uses Redis to track request counts, register the interceptor, and apply the annotation to controller methods for fine‑grained rate limiting.
This article compares the fundamentals and limitations of Redis list‑based queues with Kafka and Pulsar, explaining how partitions, cursors, replication, segment storage, and consumption models overcome Redis’s drawbacks and enable high‑performance, scalable, and highly available messaging systems.
This article compares the fundamentals and design trade‑offs of popular message‑queue middleware—Redis list, Kafka, and Pulsar—explaining their data structures, partitioning, persistence, consumer models, high‑availability mechanisms, and scalability challenges for developers and architects.
This article provides a comprehensive analysis of Redis Cluster, covering node and slot assignment, command execution, resharding, redirection, fault‑tolerance, gossip communication, scaling strategies, configuration limits, and practical code examples for building and operating a high‑availability sharded Redis deployment.
This article details Zhihu’s transition from a Sqoop‑driven data integration system to a Flink‑centric platform, covering business scenarios, historical architecture, design goals, technology choices, performance optimizations, and future plans for unified streaming‑batch processing across diverse storage systems.
This article explains what rate limiting is, why it is needed, the typical actions triggered by limiting, compares single‑node and distributed architectures, reviews four common limiting algorithms, and provides a detailed Redis‑Lua token‑bucket implementation with full source code.
This article explains how Redis, originally a single‑threaded in‑memory cache, introduced Lazy Free in version 4.0 and multi‑threaded I/O in version 6.0 to mitigate blocking deletions and improve I/O throughput, detailing the underlying event model, code implementations, performance trade‑offs, and comparisons with Tair's threading design.
This guide compiles 21 practical Redis usage guidelines covering key naming conventions, value size limits, expiration strategies, batch operations, risky commands, distributed lock patterns, cache consistency, capacity planning, and common pitfalls like cache penetration, snowball, and hot‑key issues, helping developers and operators build reliable, high‑performance Redis deployments.
This article explains how to improve Spring Cloud microservice performance by adding local and Redis distributed caching, demonstrates the necessary code changes, and discusses cache pitfalls such as penetration, avalanche, and breakdown along with lock‑based solutions.
The article explains how asynchronous replication and split‑brain situations can cause data loss in Redis clusters, and describes configuration parameters and client‑side techniques to minimize such loss while maintaining high availability.
This article introduces Redis, explains why it is popular, describes the architecture of a Redis Cluster, and provides a complete step‑by‑step tutorial for deploying, initializing, validating, and testing a Redis Cluster on Kubernetes with sample code and a hit‑counter application.
This article describes a real-time log processing platform that integrates Kafka, Flink, Drools rule engine, Redis, and Elasticsearch to unify heterogeneous log formats, extract business metrics, and provide configurable, dynamic data processing for large‑scale logging scenarios.
This article examines a real‑world incident where a Redis‑based distributed lock caused a 100‑bottle oversell of a scarce product, analyzes the root causes such as lock expiration and non‑atomic stock checks, and presents safer lock and stock‑validation solutions using Lua scripts and atomic Redis operations.
This comprehensive guide covers the core concepts of distributed systems—including CAP theory, consistency models, transaction protocols like 2PC/3PC and TCC, Redis features, persistence options, expiration strategies, memory eviction policies, distributed locking with Redis and Zookeeper, as well as an overview of Kafka's architecture and reliability mechanisms.
This comprehensive guide covers core distributed system theories, CAP consistency, transaction protocols, Redis features and persistence, Zookeeper coordination, message queue fundamentals, Kafka performance tricks, and practical solutions for caching, locking, and high‑concurrency scenarios.
This article walks through installing Docker Desktop on Apple M1 Macs, explains required Rosetta support, shows how to run and manage containers—including a Redis example—covers Docker Desktop preferences, resource settings, and built‑in Kubernetes, and highlights practical tips and known limitations.
This article compiles 40 common Redis interview questions covering fundamentals, data types, persistence, clustering, performance tuning, memory optimization, and practical usage patterns, providing concise answers that help candidates confidently tackle Redis topics and secure job offers during the competitive hiring season.
This weekly community newsletter compiles the latest technical updates, including MySQL and ProxySQL troubleshooting articles, Redis memory diagnostics, InnoDB performance insights, as well as progress reports and upcoming plans for the open‑source middleware projects DBLE and DTLE.
This article explains how to set Redis's maximum memory usage via configuration files or runtime commands, details all built‑in eviction policies, demonstrates retrieving and changing these policies, and dives into the LRU and LFU algorithms—including Java sample code and Redis's approximate LRU implementation.
This article explains why Redis can report out‑of‑memory (OOM) errors even with small datasets, describes the two types of OOM, outlines memory‑consumption categories, presents systematic troubleshooting methods, and provides a collection of useful Redis commands for diagnosing and resolving memory‑related issues.
This tutorial walks through building a scalable like feature using Spring Cloud, Redis caching, MySQL persistence, and Quartz scheduling, covering Redis installation, Spring Boot integration, data modeling, service implementation, and periodic synchronization of high‑frequency like operations to the database.
This article explains Redis's clean and elegant I/O multiplexing implementation, covering blocking I/O limitations, the reactor pattern, abstraction of select/epoll/kqueue into a unified API, key source functions, and platform‑specific module selection to achieve high‑performance single‑threaded networking.
This article compares common globally unique ID generation methods—including database auto‑increment, batch services, UUID/GUID, timestamp‑based IDs, Redis INCR, and Twitter’s Snowflake—detailing their advantages, drawbacks, and improvement options to help developers select the most suitable approach for scalability and ordering needs.
The article explores what makes code 'good'—emphasizing usability, readability, and maintainability—then details the design and implementation of a lightweight Redis‑based distributed consumption queue that alleviates HBase I/O pressure, describing its architecture, modules, logging, and performance gains.
This article explains why using the KEYS command on large Redis keyspaces can crash the service and demonstrates how the SCAN command provides a non‑blocking, incremental way to iterate over massive data safely.
This article explains how to build a highly available Redis service by analyzing common failure scenarios, evaluating single‑instance, master‑slave with one or multiple Sentinel processes, and ultimately recommending a three‑Sentinel architecture combined with a virtual IP for seamless client usage.
Redis, traditionally single‑threaded for network I/O and key‑value operations, introduced multithreading in version 6.0 to improve network I/O handling; this article explains the original single‑thread design, when multithreading is appropriate, its drawbacks, the role of I/O multiplexing, and why Redis still keeps most work single‑threaded.
This article explains the causes of partial resynchronization failures, master‑slave data inconsistency, latency, dirty data, and data‑safety risks in Redis replication, and provides concrete configuration commands and mitigation strategies to ensure reliable data consistency.
This article provides a comprehensive guide to Redis, covering its role as a non‑relational database, detailed data types and commands, persistence mechanisms (RDB and AOF), memory eviction strategies, high‑availability features such as replication, Sentinel and clustering, and solutions to typical cache problems like penetration, avalanche, and hot‑key handling.
Redis, traditionally a single‑threaded in‑memory cache, introduces Lazy Free in version 4.0 and multi‑threaded I/O in version 6.0 to mitigate blocking during large key deletions and improve performance, with detailed explanations of event handling, code implementations, limitations, and comparisons to Tair’s threading model.
This article explains the LRU (Least Recently Used) caching principle, shows how to build an O(1) LRU cache using a HashMap and doubly linked list in Java, and describes Redis's approximate LRU eviction algorithm based on a global clock and random sampling.
This article examines cache consistency challenges in Redis-backed systems and compares several update strategies—including TTL, delayed double‑delete, cache‑aside, and message‑queue approaches—detailing their workflows, code examples, advantages, and drawbacks to guide backend developers toward reliable cache invalidation.
This article walks through what Redis is, its data types, caching usage with Spring Boot, performance advantages, eviction policies, persistence mechanisms, master‑slave replication, Sentinel high‑availability, and practical interview‑style Q&A, providing a comprehensive guide for backend developers.
This article explains how Redis Sentinel provides high‑availability for Redis by continuously monitoring master and replica nodes, detecting failures through subjective and objective down states, electing a new master via quorum‑based voting, and notifying clients of the failover using Pub/Sub events.
This article explains how Redis master‑slave replication operates, covering the underlying mechanisms such as update propagation, partial and full resynchronization, the characteristics and limitations of replication, common single‑node issues, and step‑by‑step instructions for configuring and executing replication commands.
This article explains Redis fundamentals, its typical use cases, and presents a detailed cloud‑native deployment architecture on Kubernetes—including Server, Proxy, ConfigServer components, placement strategies, storage handling, scaling, and upgrade procedures—illustrated with diagrams and practical operator workflows.
This article compiles 21 practical Redis guidelines covering key naming, value sizing, expiration strategies, batch operations, risky commands, distributed lock patterns, cache consistency, capacity planning, and configuration tips, helping developers and operators build reliable, high‑performance Redis‑backed systems.
This article walks through the design, core components, task states, API endpoints, and full Java implementation of a Redis-powered delay queue using Spring Boot, complete with code samples, container structures, timer processing, and testing procedures.
This article explains Redis's original single‑threaded event loop, the performance problems it causes, and how Redis 4.0 introduced Lazy Free and Redis 6.0 added multithreaded I/O, comparing the implementation with Tair's more elegant multithreaded design.
This article explains why Redis achieves exceptionally high performance by combining pure in‑memory operations, a global hash table with O(1) lookups, efficient data structures such as SDS, ziplist, quicklist and skiplist, a single‑threaded event loop with non‑blocking I/O multiplexing, and adaptive encoding strategies.
This article presents a comprehensive design of a real‑time security monitoring and alert platform, detailing challenges in high‑concurrency risk control, an architecture that replaces OLAP polling with scalable compute services, event‑time processing, dynamic thresholding using fbprophet, and practical optimizations with Redis and ClickHouse.
This article examines common distributed ID generation methods—including UUID, MySQL auto‑increment, multi‑instance auto‑increment, Snowflake, and Redis—detailing their advantages, drawbacks, and practical use cases, and presents advanced designs such as database‑driven ID blocks, concurrency handling, and double‑buffer techniques for high‑traffic systems.
This article compiles 40 frequently asked Redis interview questions, covering its definition, data types, advantages, comparison with Memcached, persistence mechanisms, performance considerations, eviction policies, clustering, client libraries, security commands, usage scenarios, and best‑practice tips for high‑traffic production environments.
This article explains the concept of idempotency, why it is essential for HTTP interfaces, the impact on system design, and presents several practical implementation strategies—including unique primary keys, optimistic locking, anti‑repeat tokens, and downstream sequence numbers—accompanied by a complete Spring Boot example with Redis integration and test code.
When a Redis key stores a very large value, it can block the single‑threaded server and waste memory, so this article explains practical techniques such as splitting keys, using hash structures, and bucket‑based hashing to reduce I/O pressure and memory consumption.
This article explains why a low Redis memory fragmentation ratio is not necessarily caused by swap usage, demonstrates experiments with disabled swap and varying repl‑backlog‑size, and concludes that large replication buffers and small data sets can naturally produce ratios far below 1, which is normal.
Distributed locks ensure exclusive access across multiple servers in high-concurrency scenarios, and this article explains their necessity, illustrates problems with simple locks, and details practical implementations using Redis and Zookeeper, including lock acquisition, release, expiration handling, and avoiding deadlocks.
This article explains why Redis achieves exceptional speed by examining its memory‑only architecture, single‑threaded event loop, and the specialized data structures—global hash tables, SDS strings, ziplist, quicklist, skiplist, and intset—that provide O(1) or O(log N) operations, along with non‑blocking I/O multiplexing.
This article examines a real‑world flash‑sale incident where Redis distributed locks failed, causing severe overselling, and presents root‑cause analysis, safer lock implementation with Lua scripts, atomic stock handling, refactored Java code, and deeper reflections on lock necessity and further optimizations.
This article explains why Redis was originally designed as a single‑threaded in‑memory database, outlines the four main reasons for that design, describes the limitations of I/O multiplexing, and details how Redis 6.0 introduced multithreading for network request handling to improve performance under high QPS workloads.
This article explores the design and implementation of a high‑concurrency train ticket spike system, detailing load‑balancing strategies with Nginx, distributed inventory management using Redis, Go‑based services, and performance testing, while addressing challenges such as overselling, fault tolerance, and efficient resource utilization.
This article explores the challenges of designing a flash‑sale (秒杀) system—such as overselling, high concurrency, request flooding, URL protection, and database bottlenecks—and presents a complete backend architecture using Redis, Nginx, rate‑limiting, asynchronous order processing, and service degradation to achieve a stable, high‑throughput solution.
This article explains how the creator red‑packet feature was engineered to guarantee idempotent, fault‑tolerant, and high‑throughput red‑packet claims by using multi‑level caching, empty placeholders, binlog‑driven synchronization, active cache invalidation, ordered Kafka consumption, and fallback strategies to resolve cache‑DB consistency issues.
This article provides a curated collection of over 250 interview question links covering Java fundamentals, Spring framework, databases, Redis, messaging, concurrency, and system design, organized by issue numbers to help developers prepare for technical interviews.
The article explains how Redis evolves from a single‑threaded in‑memory cache to using Lazy Free and multi‑threaded I/O to alleviate blocking on large key deletions, describing the underlying event model, code implementations, performance trade‑offs, and comparisons with Tair's threading approach.
This article explains the concept of connection pools, compares pooled and direct TCP connections, demonstrates thread‑safety issues when reusing a Jedis instance in multithreaded code, and shows how to fix the problem by using JedisPool with proper resource management.
An interview with ByteDance engineer Xie Ning reveals how Redis can be transformed into a cloud‑native service on Kubernetes, covering the use of Deployments, StatefulSets, Operator patterns, dynamic storage provisioning, and the operational benefits over traditional physical‑machine deployments.
This article explains why Redis is exceptionally fast by detailing its in‑memory design, global hash table with O(1) lookups, incremental rehashing, specialized data structures such as SDS, ziplist, quicklist, skiplist and intset, as well as its single‑threaded event loop and epoll‑based I/O multiplexing.
This article explains the concepts and practical implementations of distributed locks using Redis, Redisson, and ZooKeeper, covering lock acquisition, expiration handling, atomicity, automatic renewal, and code examples for Java developers working in clustered environments.
This tutorial walks through creating two Django projects, configuring a shared session store (either a common file or Redis) to achieve single sign‑on across them, and provides full code snippets, settings adjustments, and testing steps to demonstrate seamless login synchronization.
The iQIYI International backend team boosted global video delivery by introducing a web‑cache layer, Brotli compression, and a two‑level Caffeine‑Redis caching system with pub/sub synchronization, achieving up to 6% faster First Contentful Paint, near‑100% cache‑hit rates, and measurable revenue gains.
This article explains two practical methods for keeping MySQL and Redis cache in sync—using MySQL triggers with UDF functions or parsing binlog events—and introduces the open‑source Canal project for incremental log parsing, while also discussing the pitfalls of reverse synchronization.
This article introduces Redis, explains its advantages, describes Redis Cluster architecture, and provides a detailed, hands‑on tutorial for deploying a Redis Cluster on Kubernetes using StatefulSets, PersistentVolumes, services, and a sample hit‑counter application, complete with configuration files and verification commands.
This article explains two technical methods for keeping MySQL data in sync with a Redis cache—using MySQL triggers combined with a UDF function and parsing MySQL binary logs (with Canal)—detailing their workflows, advantages, limitations, and implementation considerations.
This article explains the concept of distributed locks, outlines common application scenarios, and provides detailed Java implementations using Redis (including Redisson and RedLock), Etcd, and Zookeeper, complete with code examples and a comparative summary of their advantages and drawbacks.
This article compares Redis and Memcached across thread model, data structures, eviction policies, pipelining, persistence, high availability, and clustering, helping developers choose the most suitable in‑memory database for their specific performance and feature requirements.
This article provides a comprehensive guide to Redis high‑availability through master‑slave replication, covering the underlying architecture, step‑by‑step setup, full and partial synchronization processes, buffer management, practical pitfalls, and how the mechanism fits into broader Redis HA solutions.
This article walks through designing a ranking system for interview scenarios, comparing MySQL and Redis implementations, covering sorted‑set operations, handling daily, weekly, and multi‑day leaderboards, scaling to billions of users, and addressing practical considerations beyond pure API usage.
This article explains how to build a QR code login feature for web applications by coordinating mobile and web servers, generating UUIDs, storing temporary data in Redis, and polling for authentication, providing a practical step‑by‑step guide with diagrams.
The article compares three stock‑deduction approaches—single‑record MySQL, sharded MySQL rows, and Redis INCRBY with Lua scripts—analyzes their concurrency drawbacks, and presents a complete Java implementation using Redis, distributed locks, and callback‑based stock initialization.
This comprehensive article walks you through the entire process of identifying why Redis latency spikes, from confirming the slowdown and measuring baseline performance to analyzing slow logs, big keys, expiration patterns, memory limits, fork overhead, AOF settings, CPU binding, swap usage, memory fragmentation, network bandwidth, and finally applying practical optimization techniques.
This article explains how Redis evolves from a single‑threaded event‑driven cache to using Lazy Free for asynchronous key deletion and multi‑threaded I/O for improved performance, detailing the underlying mechanisms, code implementations, limitations, and comparisons with Tair's threading model.
This article introduces JetCache, a Java caching library that offers powerful annotations, two‑level (local and remote) caching, TTL support, and easy configuration, and demonstrates its quick start, usage in Spring Boot, unit testing, and cache statistics.
This article explores how physical design analysis—monitoring file‑system changes, commit frequency, and module size—can reveal the stability, coupling, and learning cost of a large‑scale software project, using Redis as a concrete case study and the open‑source tool Coco for measurement.
This article shares a detailed personal account of multiple Java backend interview rounds, covering technical topics such as JVM, design patterns, distributed locks, Redis, and system design, while also offering practical advice on preparation, self‑presentation, career planning, and interview mindset.
This article explains how Redis handles memory exhaustion by using key expiration commands, describes the three expiration strategies, details the eight maxmemory eviction policies, and dives into the internal LRU and LFU algorithms with their configuration parameters and code examples.
This article explains why Celery can become unresponsive on Windows, compares version stability, and shows how to configure a periodic heartbeat to Redis so that task queues stay alive, including full Python examples and Celery configuration files.
This article explores common pitfalls in RabbitMQ message delivery, explains persistence settings and the confirm mechanism, and why they alone can't ensure 100% reliability, then proposes a robust solution combining pre‑persisting messages to Redis, confirm callbacks, scheduled retries, and idempotent consumer design to achieve near‑zero loss.
This article explains that Redis stores all data primarily in memory, describes its seven core data types (String, Hash, List, Set, Sorted Set, Pub/Sub, Transactions), shows how each type is implemented internally, and provides practical examples such as caching, ranking, queues, and real‑time analytics.
This article explains why caching MySQL with Redis is essential, outlines the consistency challenges that arise, and presents four practical solutions—expiration, delete‑then‑repopulate, message‑queue updates, and binlog subscription—along with their pros, cons, and guidance for choosing the right approach in interviews.
This article explains how to protect API data exchange by using access tokens, timestamps, MD5 signatures, Redis caching, and a custom @NotRepeatSubmit annotation to prevent replay attacks and duplicate submissions in a Spring Boot backend.
This article explains how to implement API request frequency control in PHP using Redis, detailing a function that tracks per‑user request counts within a configurable time window, removes outdated entries, and returns appropriate responses when the limit is exceeded.
This article explains how to configure Redis's maximum memory, describes the various eviction policies—including noeviction, allkeys‑lru, volatile‑lru, random and ttl strategies—covers how to query and set these policies, and details the LRU and LFU algorithms used by Redis for cache management.
This article explains why duplicate requests—especially write operations—can cause serious issues, outlines common causes such as replay attacks and client retries, and provides a comprehensive server‑side solution using unique request IDs, Redis, and MD5‑based parameter deduplication with Java code examples.
Learn how to set Redis's maximum memory usage, understand its various eviction policies—including noeviction, allkeys‑lru, volatile‑lru, allkeys‑random, volatile‑random, volatile‑ttl, and the newer LFU strategies—plus see Java code examples and insights into approximate LRU implementation.
This article explains how Redis handles key expiration, the commands for setting TTL, the three expiration strategies, the eight eviction policies, and the internal LRU and LFU algorithms, including their implementation details, sampling techniques, and configuration parameters for memory management.
This article presents a comprehensive guide to Redis monitoring and alerting, covering metric classification, threshold settings, client traffic collection, host resource usage, instance health checks, cluster failover diagnostics, and detailed explanations of Redis INFO sections with practical code examples.
This article explains how to set Redis's maximum memory usage, configure eviction policies such as noeviction, allkeys‑lru, volatile‑lru, allkeys‑random, and LFU, demonstrates command‑line and configuration‑file methods, and provides a Java implementation of an LRU cache.
A large‑scale system that stacked a relational database, MongoDB, and a 200GB Redis cache suffered cascading failures, prompting a thorough analysis of Redis misuse and a redesign that introduces monitoring, controlled client libraries, proxy layers, sharding, and robust high‑availability strategies.
This article walks through the complete troubleshooting and performance‑tuning process for a high‑concurrency SSM‑based e‑commerce system, covering problem identification, root‑cause analysis, JVM, Tomcat, Redis and MySQL optimizations, traffic shaping, and the resulting stability improvements.
This guide walks you through installing JumpServer—a secure bastion host—on CentOS, covering architecture overview, MariaDB and Redis setup, Docker configuration, container deployment, key generation, UI access, and essential administration tasks such as user, asset, and permission management.
This article explains how Redis handles memory exhaustion by setting key expirations, describes the four expiration commands, details the three expiration strategies, outlines the eight eviction policies, and dives into the inner workings of Redis's LRU and LFU algorithms with configuration examples.
This tutorial explains the concept of idempotency, why it is needed for reliable APIs, the impact on system design, and provides four implementation strategies—including a detailed SpringBoot example that uses Redis tokens, Lua scripts, and unit tests—to ensure that repeated requests produce the same result without side effects.
This article explains why duplicate requests—especially those that modify data—can be dangerous, outlines common causes, and provides a comprehensive server‑side solution using unique request IDs, parameter hashing, and a Java utility class with Redis to reliably deduplicate incoming calls.
This article explains why message middleware like RocketMQ guarantees at‑least‑once delivery, the resulting duplicate‑delivery problem, and presents both transaction‑based and non‑transactional idempotency solutions—including select‑for‑update, optimistic locking, and a Redis‑backed deduplication table—to achieve exactly‑once semantics in distributed systems.
The article explains how to prevent harmful duplicate write requests on the server side by using unique request identifiers with Redis, computing MD5 digests of sorted JSON parameters, excluding volatile fields, and provides a reusable Java helper class with example code and logs.
This article provides a thorough overview of Redis, covering its core data structures, common commands, persistence options, memory management, pipelining, transactions, performance optimization, replication, clustering, and Java client choices for developers and architects.
This tutorial explains how to create a custom @AccessLimit annotation, an interceptor that uses Redis to count requests, register the interceptor in Spring Boot, and apply the annotation to controller methods to enforce per‑endpoint rate limiting.
This guide walks through setting up Apache Zeppelin as a low‑cost, SQL‑centric development platform for Flink, covering environment preparation, installation, interpreter configuration, execution modes, verification, common pitfalls, dimension‑table joins, custom UDFs, Redis integration, and dual‑stream join techniques.
This article presents common Redis interview questions covering cache penetration, breakdown, and avalanche, explains RDB and AOF persistence mechanisms with configuration commands, and details memory‑size tuning, LRU/LFU/RANDOM eviction policies, plus a practical flushAll scenario.
