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.
This article introduces Redis as an open‑source, in‑memory data‑structure store, explains its role as a NoSQL database, details its five fundamental data types, common commands, expiration handling, pipelines, and transactions, and shows how it fits into modern scaling architectures.
Version 1.0.3 of the pure PHP coroutine Wind Framework introduces a new Chan class for intra-process coroutine messaging, enhances the message queue with Redis and Beanstalk drivers supporting massive consumer counts and timeout settings, and fixes several Beanstalk client command errors.
This article explains Redis persistence mechanisms, detailing how RDB snapshots and AOF append‑only logs work, how to enable and configure them, their advantages and drawbacks, and guidance on choosing the right method for reliable data storage.
The article recounts how Postman's Service Foundation team identified the limitations of the monolithic Sync service, designed and built the Bifrost WebSocket gateway using Fastify, AWS ElastiCache for Redis, and a private API, and scaled it through horizontal expansion and custom load‑factor metrics while sharing practical engineering insights.
This article demonstrates how to back up and restore Redis data using semi‑persistent RDB snapshots, full‑persistent AOF logging, and master‑slave replication, including command‑line examples for setting keys, checking replication status, saving snapshots, promoting a slave to master, and verifying data integrity.
The article outlines typical problems caused by inconsistent Redis master‑slave settings—such as mismatched maxmemory, differing hash‑ziplist parameters, replication performance bottlenecks, and single‑point failures—and provides practical recommendations to improve reliability and data safety.
This guide shows how to set up a complete Redis monitoring stack by launching two Redis instances, a redis‑exporter collector, and Grafana‑Prometheus visualisation all via Docker, covering container creation, IP discovery, configuration files, datasource setup and dashboard creation.
This guide explains three Redis migration methods, focuses on using the third‑party tools redis‑dump and redis‑load, and provides detailed steps to upgrade Ruby, install RVM, set up redis‑dump, and export/import data in JSON format.
Redis instances provide 16 default logical databases that act as namespaces rather than separate data stores; this article explains their origin, how to configure the number of databases, proper usage of SELECT and FLUSHALL commands, and why multiple databases are unsupported in Redis Cluster mode.
Redis can experience latency spikes due to factors such as complex commands, big keys, expiration patterns, memory limits, fork overhead, AOF persistence, CPU binding, swap usage, memory fragmentation, and network saturation, and this article provides a systematic troubleshooting methodology and practical optimization solutions for each scenario.
This article introduces Redis's primary data structures—String, Hash, List, and Set—explaining their purpose, key commands, and practical usage examples, including batch operations, numeric adjustments, field management, list manipulation, and set operations, to help developers effectively work with the in‑memory database.
This article explains how to use Redis INFO and related commands to monitor critical performance metrics such as memory usage, memory fragmentation, total commands processed, latency, and key eviction, and provides practical tips for interpreting these metrics and optimizing Redis deployments.
This article compiles essential interview‑style questions and detailed answers on distributed system fundamentals—including CAP and BASE theories, consistency models, distributed transactions, Redis features and persistence, Zookeeper coordination, Kafka architecture, and common design patterns for high‑concurrency scenarios.
This tutorial walks through building a Redis 6+ cluster on a single server, covering node startup, cluster handshake, slot assignment, master‑slave replication, command routing, failover handling, and practical scaling operations such as adding and removing nodes.
This article analyzes the characteristics of Redis and Memcached, explains typical design mistakes such as inconsistent hashing, cache avalanche, penetration, and hot‑key issues, and provides practical solutions like consistent hashing, binlog‑driven cache invalidation, key versioning, and distributed locking to improve cache reliability and performance.
This article details how JD.com designed, scaled, and refined its mask reservation backend during the COVID‑19 pandemic, addressing extreme traffic spikes, hot‑key issues, MySQL bottlenecks, and introducing a circuit‑breaker mechanism to protect the overall transaction system.
This article presents a cinema ticketing system built with the SSM framework, MySQL, Redis, Alipay sandbox, LayUI, and Baidu ECharts, highlighting its architecture, features such as payment and seat selection, and providing source code link and screenshots.
This comprehensive guide details the essential redis.conf parameters—including daemonization, networking, memory limits, logging, slowlog, advanced data structure encodings, replication options, and persistence settings—providing clear explanations and recommended values for optimal Redis deployment.
This article examines the challenges of building a flash‑sale (秒杀) system—such as overselling, massive concurrent requests, URL exposure, and database bottlenecks—and presents a comprehensive backend architecture that combines separate databases, dynamic URLs, static pages, Redis clustering, Nginx load balancing, SQL optimization, rate‑limiting, asynchronous order processing, and service degradation techniques.
This technical guide walks through the fundamentals of Prometheus, compares it with Zabbix, demonstrates high‑availability setups, remote storage with InfluxDB, multi‑instance Redis monitoring, and Grafana integration, providing concrete configuration examples and best‑practice recommendations for reliable ops monitoring.
This article explains how Redis can be used as a lightweight message‑queue solution by leveraging its List, Pub/Sub, and Stream data structures, covering core commands, blocking consumption, acknowledgment mechanisms, consumer groups, and practical usage patterns for distributed systems.
The article introduces go-mysql-transfer, a Go-implemented MySQL binlog incremental synchronization solution that avoids extra components, supports multiple downstreams like Redis, offers Lua scripting, Prometheus monitoring, high‑availability clustering, retry mechanisms, full data initialization, and provides installation, deployment, and performance testing details.
This article walks through three progressively better implementations for a complex e‑commerce search API—starting with a monolithic SQL query, then splitting the query and adding indexes, and finally using Redis sets and sorted sets to cache filter results, handle pagination, and achieve production‑grade performance.
This article explores the key challenges of designing a flash‑sale (秒杀) system—such as overselling, high concurrency, request flooding, and database strain—and presents a comprehensive backend architecture with database design, dynamic URLs, caching, rate limiting, async ordering, and service degradation techniques.
This article presents an interview scenario where a candidate is asked about Redis cache avalanche, explains the phenomenon, and offers four practical mitigation strategies—including cache pre‑warming, mutex locking, staggered expiration, and high‑availability designs—to keep backend databases from being overwhelmed.
Idempotency ensures that repeated API calls produce the same effect as a single call, preventing duplicate submissions, token misuse, and inconsistent data; this guide explains the concept, its importance, HTTP definitions, impact on systems, and presents four practical implementation methods—unique keys, optimistic locking, token‑based guards, and sequence numbers—with full SpringBoot and Redis code examples.
This tutorial walks through setting up a Redis Cluster on a single server with six nodes, covering node startup, handshake, slot assignment, master‑slave replication, command routing, failover handling, and practical scaling operations such as adding, rebalancing, and removing nodes.
This article explains the cardinality‑counting problem behind DAU/MAU and unique visitor metrics, compares naïve solutions like Set, Bitmap and Bloom filter, introduces big‑data algorithms such as Linear Counting, LogLog and HyperLogLog, and shows how Redis implements HyperLogLog with dense and sparse storage optimizations.
This article walks through the design, pitfalls, and deep optimizations of a Node.js + TypeScript backend that periodically syncs enterprise WeChat organization data to a MySQL store and provides a phone‑number lookup API, offering practical solutions for rate limits, process management, database conflicts, and error recovery.
The document provides a detailed technical overview of New Oriental's unified management platform, describing its five core modules—Redis platform, microservice platform, gateway platform, app management platform, and permission management platform—including monitoring, cluster management, service registration, and access control features.
The article explains the concepts of cache penetration, cache breakdown, and cache avalanche in Redis, illustrates each problem with real‑world analogies, and presents practical mitigation techniques such as null caching, Bloom filters, mutex locks, asynchronous refresh, varied TTLs, and clustering to ensure robust backend performance.
This article explains why Redis latency can suddenly increase, covering high‑complexity commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network overload, and provides concrete diagnostic commands and mitigation strategies.
This article explains Redis’s memory eviction policies, expiration strategies, common cache problems such as penetration, breakdown, and avalanche, outlines deployment modes, compares RDB and AOF persistence, and lists typical business scenarios for using Redis as a high‑performance key‑value store.
This article examines common causes of increased latency in Redis—including high‑complexity commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network saturation—and provides practical monitoring and configuration techniques to diagnose and reduce delays.
This article explores the design of a high‑concurrency train ticket‑seckill system, covering 12306 backend architecture, multi‑layer load balancing, Redis‑based stock deduction, Go code examples, performance testing, and strategies to prevent overselling and ensure fault tolerance.
This article explains why the Flask‑Redis extension cannot switch Redis databases, describes the underlying limitation of redis‑py, and provides a Python class library that enables dynamic database selection, data push/pull, and clean connection handling for Flask applications.
This tutorial walks you through installing JumpServer—a bastion host for centralized server management—by setting up MariaDB and Redis on separate nodes, configuring Docker, pulling the JumpServer image, generating required secret keys, and finally configuring users, groups, assets and session replay through the web UI.
This article explains the concepts of cache penetration, cache breakdown, and cache avalanche in Redis, presents common mitigation techniques such as request validation, empty‑value caching, Bloom filters, mutex locks, and high‑availability strategies, and includes Java code examples for practical implementation.
This article explains Redis persistence mechanisms, detailing how the in‑memory database can lose data on shutdown and how the two main durability options—RDB snapshots and AOF append‑only logs—work, their configuration commands, their advantages, disadvantages, and guidance on choosing the right approach for production use.
This article explains how Redis can be used to build lightweight, high‑performance message queues by leveraging lists for simple queues, sorted sets for delayed delivery, Pub/Sub for multicast, and the Stream data structure for durable, scalable messaging, while also covering practical PHP implementations, acknowledgment, retry, graceful restart, and rate‑limiting techniques.
This article recounts how a Tubi engineering team diagnosed a surprising latency increase after adding Redis cache to an Elixir manifest‑fetch API, identified a hidden CPU‑heavy Regex.replace/4 bug, applied targeted optimizations, and contributed a fix to the Elixir core.
This article explains how distributed lock requirements arise when scaling from monolithic to multi‑server architectures, reviews the evolution of Redis‑based locking mechanisms from simple SETNX to Lua scripts and Redisson's advanced features, and provides detailed source‑code analysis of Redisson's lock, unlock, and lock acquisition implementations.
This article describes how CTrip tackled rapid Redis cluster growth by moving from vertical scaling to a containerized horizontal splitting approach, then introduced a binlog‑server based horizontal expansion and shrinkage method that reduces operation time, eliminates data migration, supports both scaling up and down, and improves resource utilization.
This article provides a hands‑on guide to using IdentityServer4 in the Fuluteng project, covering signing credentials, client and resource stores, persisted grant storage with Redis, various OAuth2 grant types including client credentials, authorization code, password, and custom extensions such as SMS and third‑party logins, and demonstrates role‑based authorization and JWT configuration.
This article explains the benefits of short URLs, outlines their basic workflow, and details a backend design that uses an incremental issuer, base conversion, persistent storage, caching, batch ID allocation, and distributed issuers to achieve efficient, high‑concurrency short‑URL generation.
This article explains why short URLs are used in SMS and other platforms, outlines their benefits, describes the basic workflow of mapping long URLs to short ones, and dives into backend design choices such as incremental ID generation, storage strategies, caching, batch allocation, and distributed generation using Redis and Java.
This article evaluates and compares a range of Redis visualization tools—including desktop clients, web applications, and IDE plugins—by examining their features, usability, platform support, pricing, and command‑line integration to help developers choose the most suitable solution for their workflow.
This article presents thirteen practical Redis performance‑optimization rules—covering command complexity, key expiration, data structures, persistence, hardware choices, clustering, memory fragmentation, and client‑side techniques—to help developers identify bottlenecks and boost throughput and latency in production environments.
This comprehensive guide explores Redis internals, covering its core data types and their low‑level implementations, persistence mechanisms like RDB and AOF, performance tricks, common pitfalls such as cache avalanche and split‑brain, distributed locking strategies, expiration and eviction policies, high‑availability architectures, and rate‑limiting techniques.
This article explains Bloom filters, their core principles, typical use cases like cache penetration and large‑scale membership testing, and demonstrates practical Java implementations using Guava and Redis, including code examples, performance analysis, and discussion of their advantages and limitations.
This article explains three Redis-based approaches—using Hashes, Bitsets, and the HyperLogLog probabilistic algorithm—to count daily website visits, detailing command usage, advantages, disadvantages, and implementation considerations for high‑traffic sites, including handling logged‑in and anonymous users, memory consumption, and accuracy trade‑offs.
lock4j-spring-boot-starter is a Spring Boot distributed lock library that provides simple yet powerful locking capabilities with support for Redisson, RedisTemplate, and Zookeeper, and the 2.1.0 release adds global configuration, executor enhancements, default priority ordering, and both declarative and programmatic usage options.
This article explains how Spring Boot integrates Redis, reveals a common pitfall where different RedisTemplate beans cause null reads despite existing data, and shows how to diagnose and fix the issue by aligning bean types and injection annotations.
This guide shows how to create a custom Scrapy command to launch every spider at once, separate each spider's settings for better modularity, and resolve video download problems by adjusting request headers and handling file saving correctly.
This article analyzes a P0 flash‑sale incident where Redis distributed locks expired and non‑atomic stock checks caused a 100‑bottle over‑sell, then presents safer lock implementations, atomic stock decrement, and architectural improvements to avoid similar failures.
This guide walks through Redis’s eight core data structures—String, List, Set, Hash, Sorted Set, Geospatial, HyperLogLog, and Bitmap—detailing their commands, practical usage scenarios, and example interactions to help developers ace interview questions and optimize NoSQL solutions.
