This article provides a comprehensive guide to Redis memory architecture, covering memory analysis, fragmentation, object and buffer usage, Linux copy‑on‑write effects, maxmemory settings, eviction policies, and practical tips for monitoring and optimizing Redis in production environments.
This article explains why distributed locks are needed, outlines their five essential properties, compares common implementation methods such as database, ZooKeeper, and Redis locks, and provides Java code examples for acquiring, releasing, re‑entering, and safely extending locks with watchdog mechanisms.
This article explains a three‑step architecture for describing, storing, and calculating fan‑based discounts, introduces a crowd‑based abstraction to accelerate high‑traffic queries, and details a hybrid offline‑plus‑real‑time data‑sync strategy that ensures consistency and millisecond‑level response times.
This article explains how to use redis-benchmark for performance testing, compares single‑node and cluster throughput, and details Redis Cluster's hash‑slot architecture, including CRC16 hashing, slot allocation, scaling considerations, and operational nuances.
This article details the design and implementation of a high‑performance, highly available membership platform serving billions of users, covering dual‑center Elasticsearch clusters, traffic‑isolated three‑cluster ES architecture, Redis caching strategies, MySQL dual‑center partitioning, seamless migration, and fine‑grained flow‑control and degradation mechanisms.
This article introduces Redis Sentinel as the official high‑availability solution for Redis, explains its core functions, provides configuration examples, compares three ways to receive failover notifications (script, client subscription, and indirect service), and offers design recommendations for robust production deployments.
This article outlines comprehensive Redis development standards, covering key naming conventions, value design, lifecycle management, command usage guidelines, prohibited commands, batch operations, transaction considerations, and Lua scripting constraints, aiming to reduce common pitfalls and improve performance and maintainability.
This article explains how to use Redis Sentinel for high‑availability deployments, covering its core features, configuration files, startup commands, monitoring behavior, three methods of receiving failover notifications, and recommended architectural patterns for robust backend systems.
This guide outlines Alibaba Cloud Redis development standards, covering key naming conventions, value design, command usage, client configuration, eviction policies, and tools for data synchronization, big-key management, and monitoring, helping developers avoid common pitfalls and optimize performance.
This article reviews various distributed ID generation methods—including UUID, database auto‑increment, segment mode, Redis INCR, Snowflake, Meituan Leaf, Baidu UidGenerator, and Didi TinyID—explaining their principles, advantages, drawbacks, and providing Java code examples for each.
This comprehensive guide covers why Redis is fast, its underlying data structures, single‑threaded and epoll models, cache eviction policies, persistence mechanisms, high‑availability architecture, performance bottlenecks, distributed locking, cache avalanche/penetration strategies, data skew handling, and bitmap applications, providing essential knowledge for interview preparation.
This tutorial shows how to quickly set up a full PHP 8.2, Nginx, MySQL 8, Redis 6, and Composer environment on Ubuntu 20.04 by configuring Alibaba Cloud apt mirrors, installing required packages, adjusting configurations, and verifying the stack, all in roughly twenty minutes.
This article details the end‑to‑end design of a coupon system for a rental listing platform, covering business flow, database schema, state management, caching strategies, distributed locking, and optimization techniques using design patterns, Redis, MySQL, and message queues.
This guide explains why Logstash may import fewer rows than exist in a PostgreSQL table, and provides two practical methods—shell‑script ID comparison and Redis‑accelerated set operations—to reliably detect and troubleshoot missing records in Elasticsearch.
This article provides a detailed walkthrough of Redis's internal architecture, covering the client module, event‑driven networking, command processing, memory management, persistence strategies, high‑availability features, and the low‑level data structures such as redisServer, redisDb, dict, dictEntry, and redisObject that power its fast key‑value storage.
This article explains how to protect PHP‑based API endpoints by using request signatures, nonce and timestamp validation, Redis‑backed rate limiting, and additional best practices such as HTTPS, access control, input validation, logging, and security audits.
This article explains the step‑by‑step evolution of Redis‑based distributed lock implementations—from a simple SETNX approach to a robust solution using UUIDs, expiration, atomic Lua scripts, and finally Redisson’s high‑level lock API—illustrating common pitfalls and their fixes.
This article explains how to prevent overselling in high‑concurrency scenarios by using Redis‑based distributed locks in PHP, detailing initialization, lock acquisition with setnx, unlocking with del, and providing complete sample code along with best‑practice considerations.
This article explains how to use PHP and Redis to create a blocking lock for a game room, safely add users while preventing dirty reads, and release the lock atomically with a Lua script, providing complete code examples and practical tips.
Vivo’s push platform achieves high‑availability disaster recovery by deploying multi‑region broker clusters, implementing dual‑active logic nodes across two data centers, adding a Kafka‑backed buffering layer for traffic spikes, and using a hybrid Redis‑plus‑disk KV storage scheme to ensure durable, real‑time message delivery.
This article explains why time‑consuming business operations need a distributed lock, walks through using Redis as a lock with Spring AOP, details the lock‑acquire, timeout, and renewal mechanisms, provides full code examples, testing steps, and best‑practice recommendations for reliable concurrency control in Java back‑end services.
This article describes the design, technology choices, architecture, and implementation details of an automated payment channel management system that uses Redis‑based time‑series storage, custom circuit‑breaker logic, and monitoring to achieve fast fault detection, accurate alerting, and future automated failover.
This article compares JWT and session authentication, explains their differences, security and performance trade‑offs, and provides a complete Java implementation with Redis integration, guiding developers on selecting and implementing the most suitable authentication method for distributed backend systems.
This article details Baidu Cloud's PegaDB—a Redis‑compatible, high‑capacity, low‑cost distributed KV store—covering its design choices, architecture, performance and replication optimizations, multi‑region active‑active support, native JSON model, community contributions, and future roadmap.
This article explains how KeyDB, a multithreaded fork of Redis, redesigns the thread model, connection handling, lock mechanisms, and introduces active‑replica features while staying fully compatible with the Redis API.
This article explores the design of a high‑concurrency ticket‑spike system like 12306, covering large‑scale architecture, load‑balancing strategies, inventory deduction techniques, and a complete Go/Redis implementation with performance testing and fault‑tolerance considerations.
This article explains how to protect time‑consuming business operations using a Redis‑based distributed lock implemented with custom annotations, Spring AOP, and a scheduled thread pool that automatically extends lock expiration to avoid premature release.
This article demonstrates a step‑by‑step implementation of API request throttling in a Spring backend using an Interceptor and Redis, covering the underlying principle, configurable limits, custom annotations, reflection‑based flexibility, and practical considerations such as path parameters and real‑IP handling.
Redis is an open‑source, in‑memory key‑value data‑structure server that serves as a fast cache and primary database, offering various deployment options—including single instances, high‑availability setups, Sentinel, and clustering—along with flexible persistence mechanisms such as RDB snapshots and AOF logging.
This article explains Redis’s primary roles as a high‑speed cache, in‑memory database, and analytics engine, compares it with relational databases, details its data structures, single‑threaded performance, persistence options, expiration and eviction policies, distributed lock implementation, and strategies for cache penetration, breakdown, and avalanche.
This article explains how to protect time‑consuming business operations by using Redis as a distributed lock, designing a custom @RedisLock annotation, applying Spring AOP to intercept methods, handling lock acquisition, expiration, renewal via a ScheduledExecutorService, and releasing the lock safely after execution.
This article explains why certain Redis commands, persistence mechanisms, and large keys can block the single‑threaded server, detailing the underlying causes, how to detect big keys, and practical ways to mitigate blocking in production environments.
The article describes a data application platform that enables business users to configure custom data selection rules for opportunities, create scheduled tasks, perform large‑scale data comparison, handle task dispatch with Redis queues, and implement rate‑limiting using sliding windows to ensure reliable processing.
This article compares session‑based and JWT‑based authentication, discusses their advantages, disadvantages, security and performance considerations, and provides a complete Java Spring Boot implementation—including dependency configuration, utility classes, login/logout/password update logic, and interceptor handling—using Redis for token management.
This article explains the different types of auto‑increment identifiers used by MySQL—including table primary keys, InnoDB row_id, Xid, trx_id, and thread_id—covers their limits and behaviors when they overflow, and introduces Redis as an external auto‑increment key solution.
The article examines a real‑world incident where an unsafe Redis command caused a $4 million loss, then demonstrates performance testing with ten million keys, shows how to disable dangerous commands, replace KEYS with SCAN, and avoid big‑key issues for safer database operations.
Async‑fork shifts the costly page‑table copying from Redis’s parent process to its child, allowing the parent to resume handling queries instantly and cutting snapshot‑induced latency spikes by over 98%, thereby dramatically improving tail latency during AOF rewrites, RDB backups, and master‑slave synchronizations.
The article explains the AKF Scale Cube model—horizontal replication (X axis), functional decomposition (Y axis), and data/service partitioning (Z axis)—and demonstrates how these three scaling dimensions can be applied to backend systems such as Kafka and Redis to achieve high availability, performance, and fault isolation.
This article details the design and implementation of a high‑availability, billion‑scale membership system, covering Elasticsearch dual‑center clusters, traffic‑isolated architectures, deep ES optimizations, Redis caching strategies, MySQL migration with dual‑center partitioning, abnormal member relationship handling, and future fine‑grained flow‑control and degradation plans.
This article demonstrates how to prevent abusive API calls in a Spring Boot application by using an Interceptor together with Redis for counting requests, and extends the solution with configurable custom annotations and reflection to allow per‑endpoint rate‑limit settings.
The article explains how Redis cache expiration can cause a cache avalanche, describes typical scenarios, and presents mitigation techniques such as semaphore-based rate limiting and fault tolerance, accompanied by a Java service example demonstrating lock, semaphore, and cache handling.
This tutorial walks through creating a reusable SpringBoot starter that combines Guava's local token‑bucket limiter and Redis's distributed limiter, allowing developers to toggle between them via a simple configuration property and integrate the solution seamlessly with AOP and conditional beans.
This article presents a comprehensive, seven‑dimensional design for a flash‑sale (秒杀) system, covering business characteristics, overall architecture, peak‑limiting, Nginx configuration, page optimization, Redis clustering, message‑queue throttling, database design, captcha mechanisms, and key precautions for achieving high throughput and reliability.
This article introduces Redis Sets as unordered unique string collections, explains their ideal use cases, and provides detailed walkthroughs of creation, query, update, and deletion commands—including SADD, SREM, SISMEMBER, SCARD, SMEMBERS, SSCAN, SINTER, SUNION, and SDIFF—along with underlying encoding mechanisms.
This article outlines a comprehensive flash‑sale system architecture covering front‑end separation, Nginx static handling, traffic shaping, Redis caching and locking, message‑queue throttling, database sharding, and captcha mechanisms to achieve high concurrency while ensuring security and reliability.
This article explains how to implement interface rate limiting in a Spring application by creating custom annotations, using AOP for method interception, and leveraging a Redis‑like ConcurrentMap cache to control request counts within a fixed time window.
This article explains why exposed web APIs are vulnerable, introduces anti‑tampering and anti‑replay techniques, and provides a complete Spring Boot implementation—including request signing, timestamp and nonce validation, and Redis storage—to protect API endpoints from malicious reuse.
This article walks through the step‑by‑step evolution of Redis‑based distributed lock implementations—from simple SETNX locking to atomic expiration, UUID‑based ownership, Lua‑scripted safe release, and finally using Redisson’s high‑level lock API—illustrating common pitfalls and robust solutions.
To reduce database load from high‑frequency like and favorite actions, the article outlines a backend solution that stores per‑article like data in Redis hashes, periodically synchronizes the cached data to MySQL using Quartz scheduled jobs, and shows how to indicate whether a user has liked each article.
This article walks through the design and implementation of a Redis‑based distributed lock for time‑consuming business operations, covering annotation creation, AOP pointcut setup, lock acquisition and release, timeout handling with a renewal thread, testing, and practical code examples.
This article explains three practical approaches—separate microservices, gateway + Redis whitelist, and gateway + AOP—to restrict external access to internal APIs, and provides a detailed Spring Cloud Gateway and AOP code implementation for Java microservice architectures.
The article investigates why a MySQL‑slave machine shows low free memory despite modest MySQL and Redis usage, revealing that massive hidden files under /run/systemd/users and tmpfs‑based shared memory consume several gigabytes, and proposes practical remediation steps.
This article demonstrates a complete Spring Boot solution for limiting how many times a specific API can be called by a user within a given time window, using a custom @RequestLimit annotation, Redis for counting, and an interceptor to enforce the rule.
This guide explains how to integrate the DeWu API automation platform, detailing usage scenarios for developers, testers and data generators, optimal timing for case creation, maintenance‑reducing templates, reusable components, test‑plan execution, and common pitfalls with solutions, ultimately streamlining test management and boosting efficiency.
A recent Redis‑py library vulnerability caused ChatGPT to expose personal data of about 1.2% of Plus users, prompting an OpenAI apology, a detailed post‑mortem, and a series of backend and security fixes to prevent similar incidents.
This article provides a comprehensive overview of Redis—including its architecture, common data structures, real‑world usage scenarios such as caching, counters, and distributed locks—followed by detailed QA test cases, common pitfalls like cache penetration, and practical mitigation strategies.
A recent bug in the open‑source redis‑py library caused ChatGPT to leak personal data of about 1.2 % of Plus users, allowing some users to see others' names, emails, and partial credit‑card details; OpenAI issued an apology, published a post‑mortem, and deployed a patch to fix the Redis Cluster async client issue.
This article explains Java rate‑limiting fundamentals, covering time‑window and resource dimensions, common algorithms such as token bucket, leaky bucket and sliding window, and practical solutions using Guava, Nginx, Redis, Sentinel, and Tomcat for both single‑node and distributed environments.
Last Monday, a Redis client bug caused ChatGPT to leak user conversation histories and personal details of about 1.2% of Plus subscribers, prompting OpenAI to temporarily shut down the service, investigate, and release a patch fixing the underlying Redis‑py issue.
This article explains how to design an effective multi‑level cache architecture for microservice systems, covering client‑side static resource caching, application‑layer CDN and Nginx caching, service‑layer in‑process and distributed caches, consistency challenges, and practical scenarios for using each layer.
This article provides a thorough overview of rate limiting, covering its basic concepts, common algorithms such as token bucket, leaky bucket and sliding window, and practical implementation methods across Nginx, Tomcat, Guava, Redis, Sentinel and other middleware for both single‑machine and distributed systems.
This article dissects the architecture of a 12306‑style ticket‑spiking service, explaining load‑balancing strategies, weighted Nginx routing, local and remote stock deduction using Go and Redis, and demonstrates performance testing that achieves thousands of requests per second while preventing oversell and undersell.
Echo is a full‑stack open‑source Java community system built with Spring Boot, MyBatis, MySQL, Redis, Kafka and Elasticsearch, offering modules like posts, comments and notifications, and the article provides its core tech stack, development environment, local setup steps, deployment architecture, demo screenshots and source code access.
This article details a comprehensive performance testing workflow—including requirement analysis, script recording with BlazeMeter, data construction, iterative optimization, and final results—targeting a web application that must handle over 5,000 TPS with 2 million database records, highlighting bottlenecks in Redis, MySQL, and code logic.
This article explains the need for distributed locks in multi‑node systems, describes their core characteristics, and compares popular implementation approaches such as database‑based optimistic and pessimistic locks, Redis atomic locks, and ZooKeeper sequential node locks, highlighting their principles and trade‑offs.
This article examines Redis List interview topics, covering FIFO misconceptions, underlying encodings across versions, ZIPLIST compression mechanics, backward traversal, and the time complexities of node count queries for both ZIPLIST and LINKEDLIST implementations.
Redis version 7.0.10 has been released, addressing a critical security vulnerability (CVE‑2023‑28425) in the MSETNX command, fixing several bugs including memory‑usage issues with large stream nodes and client reply handling, and providing updated release notes on GitHub.
This article explains how Redisson implements distributed locks on Redis, covering basic concepts, a simple lock with Lua scripts, reentrancy handling, automatic lock renewal via WatchDog, and the advanced fair lock mechanism that ensures FIFO ordering using Redis lists and sorted sets.
This article provides a comprehensive overview of rate limiting, covering basic concepts, common algorithms such as token bucket, leaky bucket, and sliding window, and practical implementation methods across Nginx, Tomcat, Guava, Redis, and Sentinel for distributed backend systems.
This article presents a comprehensive Netty TCP demo project, covering its architecture, module layout, business flow, detailed Java code for message queuing, client execution, handler implementation, testing endpoints, and deployment considerations, providing a practical learning resource for backend developers.
This article explains how to handle 2 GB video uploads by splitting files into chunks, using breakpoint resume and instant transfer techniques, and leveraging Java's RandomAccessFile together with Spring Boot and Redis to manage upload state, merge chunks, and store the final file.
This article explores various distributed ID generation strategies—including UUID, database auto‑increment, segment mode, Redis INCR, Snowflake, Meituan Leaf, Baidu UidGenerator, and Didi TinyID—detailing their principles, advantages, drawbacks, and Java code examples to help developers choose the right solution for high‑scale systems.
This article explains Redis's in‑memory database persistence mechanisms—including RDB snapshots and AOF logging—detailing configuration, automatic and manual triggers, advantages and drawbacks, as well as Redis transaction commands and pipeline usage, providing practical code examples to help developers master data durability and performance.
The article explains why distributed systems need globally unique identifiers, outlines strict generation rules and availability requirements, compares common approaches such as UUID, database auto‑increment and Redis, and provides a detailed overview and Java implementation of Twitter's Snowflake algorithm.
This article explains three Redis‑based rate‑limiting techniques—using SETNX, sorted sets, and a token‑bucket with lists—providing code examples, discussing their advantages and drawbacks, and showing how to integrate them into Java Spring applications to protect high‑concurrency services.
This article explores Redis’s evolution from its 2009 inception, outlines major version releases, examines its in‑memory design, efficient data structures, encoding schemes, single‑threaded event loop with epoll, and benchmark results, illustrating why Redis achieves exceptionally high throughput and low latency in real‑world deployments.
This article details the architecture, component‑based design, dynamic template generation, batch processing, activity management, and technical challenges such as custom component rendering, condition‑expression creation, and high‑concurrency coupon issuance for a scalable e‑commerce coupon platform.
This article outlines sixteen practical Redis usage scenarios—including caching, distributed sessions, locks, ID generation, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, filtering, follow relationships, and leaderboards—explaining each concept and providing example code snippets for implementation.
The article explains Redis master‑slave asynchronous replication, describes how repeated full‑sync requests from slaves can cause a replication storm that overloads CPU, memory and network, and offers practical solutions such as limiting data size, adjusting buffer limits, and redesigning deployment topology.
This article explains two technical solutions for keeping MySQL data in sync with Redis cache—using a MySQL trigger with a UDF function and parsing MySQL binlog events—while also reviewing the Canal open‑source tool and discussing their trade‑offs and implementation details.
This article explains the concepts of cache penetration, cache breakdown (stampede), and cache avalanche in Redis, and provides practical solutions such as parameter validation, null‑value caching, Bloom filters, mutex locks, hot‑data non‑expiration, and randomizing expiration times, accompanied by Java code examples.
This article introduces KeyDB, a high‑performance Redis fork that adds multithreading, a redesigned thread model, a spin‑lock fastlock mechanism, and active‑replica capabilities, while remaining fully compatible with Redis protocols and offering up to double the throughput on the same hardware.
The article presents a detailed guide on designing and implementing fine-grained permission control for microservices using Apache Shiro, Spring Boot, Dubbo, and Redis to share session data across services, including code examples, configuration steps, and testing of role‑based access.
This article explains how Redis ensures data durability by using two persistence strategies—Append Only File (AOF) and Redis Database (RDB) snapshots—detailing their operation, configuration options, trade‑offs, rewrite processes, and how they handle expired keys and recovery.
This article shares a practical, seven‑step methodology for tackling large open‑source projects like Redis, covering project mapping, prerequisite knowledge, starting with core modules, following the main execution path, handling complex functions, branching into secondary features, and finally filling knowledge gaps.
This article explains Redis's compressed list structures—ZIPLIST and its successor LISTPACK—detailing their layouts, encoding schemes, query and update complexities, and how LISTPACK resolves ZIPLIST's chain‑update performance issues to provide a more memory‑efficient list implementation.
This article provides a comprehensive guide to Redis Cluster, covering its sharding mechanism, hash slot mapping, replication and automatic failover, client data location, slot reassignment, MOVED/ASK redirection, communication overhead, and practical tuning tips for large‑scale deployments.
The article explains the classic cache consistency problem between MySQL and Redis, analyzes how inconsistencies arise, and details four cache‑update design patterns—delete‑then‑update, cache‑aside, read/write‑through, and write‑behind—highlighting their workflows, advantages, and drawbacks.
This article presents sixteen typical Redis use cases—including caching, distributed locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, product tags, filtering, follow relationships, and ranking—each explained with practical code snippets and command examples.
This tutorial explains how to achieve exactly‑once semantics when streaming data from Kafka to Redis using Apache Flink's TwoPhaseCommitSinkFunction, covering Redis transaction basics, utility classes, sink implementation, testing steps, and solutions to common connection and transaction bugs.
Redis uses key expiration commands, periodic scanning, and a combination of lazy and active deletion strategies, and when memory is full it applies one of eight eviction policies—including refined LRU and LFU algorithms with sampling and decay mechanisms—to decide which keys to discard.
This article introduces Redis List as a linked collection of strings, explains its size limits, common CRUD commands, read operations, and dives into the underlying encodings—ZIPLIST, LINKEDLIST, and the hybrid QUICKLIST—highlighting when each is used.
This article explains the concepts of Redis cache avalanche, penetration, and breakdown, illustrates real‑world incidents, and provides pre‑, during‑, and post‑failure strategies such as high‑availability setups, local caches with rate limiting, and defensive caching of empty values.
This article provides a comprehensive overview of Redis, covering why it is used as a cache, its single‑threaded efficiency, multithreading in version 6.0, common data structures and their use cases, pipeline advantages, persistence mechanisms, transactions, Bloom filter for massive URL checks, internal data organization, and incremental rehashing.
This article provides a comprehensive overview of Redis as a NoSQL in‑memory database, covering its core data structures, special types, transaction model, RDB and AOF persistence, publish/subscribe, master‑slave replication, Sentinel failover, and common cache pitfalls such as penetration, breakdown and avalanche, with practical mitigation strategies.
This article surveys eleven Java techniques for delayed task execution—including DelayQueue, Timer, ScheduledThreadPoolExecutor, RocketMQ, RabbitMQ, Redis key‑expiration, Redisson, Netty, Hutool, Quartz and simple polling—explaining their core principles, code examples, and when each approach is appropriate.
This article surveys eleven practical techniques for implementing delayed tasks in Java, covering JDK utilities like DelayQueue, Timer, and ScheduledThreadPoolExecutor, as well as message‑queue solutions such as RocketMQ, RabbitMQ, Redis key‑expiration, Redisson, Netty, Hutool, Quartz, and simple polling, with code demos and implementation principles.
This article provides a comprehensive overview of Redis, covering its role as an in‑memory data‑structure server, various deployment topologies such as single instances, high‑availability, Sentinel, replication, and clustering, as well as its persistence mechanisms including RDB, AOF, and fork‑based snapshots.
KeyDB is a high‑performance, multithreaded fork of Redis that retains full protocol compatibility while offering double the query throughput, reduced latency, and features like Active‑Replication, fastlock spin‑locks, and advanced client‑connection management, making it a compelling drop‑in replacement for Redis deployments.
This article explains Redis's three persistence options—Append‑Only File (AOF), Redis DataBase snapshots (RDB), and the hybrid mode—detailing their inner workings, configuration strategies, performance trade‑offs, and how to choose the most reliable solution for a given workload.
