When Redis memory reaches its configured maxmemory limit, it triggers a set of eviction policies—such as noeviction, allkeys‑lru, volatile‑lfu, and others—to decide which keys to discard, and this article explains how to view, configure, and understand each strategy.
This article explains why correctly configuring the Redis client PoolSize in Go is crucial for performance and stability, outlines key factors such as concurrency, latency, and resource limits, and provides practical strategies, benchmarking methods, and sample code to help developers determine the optimal pool size.
This article details how Instagram grew from zero to 14 million users in just over a year using three engineers by applying three core principles and a reliable AWS‑based tech stack covering frontend, load balancing, backend, PostgreSQL sharding, S3 storage, Redis caching, asynchronous task queues, and comprehensive monitoring.
Redis announced a shift from the permissive BSD license to a dual‑license model (RSALv2 and SSPLv1), restricting free use by cloud providers, sparking industry debate and prompting developers to consider alternative implementations and the broader impact on open‑source ecosystems.
Redis announced it will replace its BSD‑3‑Clause license with a source‑available dual licensing model—SSPLv1 and RSALv2—starting with Redis 7.4, keeping the community edition free for developers while requiring cloud providers to secure commercial agreements, yet leaving existing enterprise users and client‑library developers under unchanged, permissive terms.
Redis is widely known as a high‑performance cache, but its rich data structures, persistence options, and distributed features enable it to serve as a primary storage engine for many internet services, from user profiles and leaderboards to rate limiting, messaging, and geo‑location, while presenting scalability and reliability challenges.
This article compiles a comprehensive Java backend interview guide covering Redis fundamentals, thread creation methods, thread‑pool pitfalls, Spring ecosystem relationships, IoC/AOP principles, shallow vs deep copying, collection cloning, differences between interfaces and abstract classes, and string handling classes, providing concise explanations and code examples for each topic.
This article introduces Bloom filters, explains their probabilistic principles, advantages and drawbacks, details how to add and query elements, derives false‑positive formulas, provides Guava, Redisson, Redis‑module, and custom bitmap implementations with code samples, and showcases real‑world business scenarios and performance benefits.
Redis announced that starting with version 7.4 it will abandon the BSD 3‑Clause license in favor of a dual SSPLv1/RSALv2 model, making the source code source‑available while keeping the community edition free, and clarifying the impact on cloud providers, partners, and end‑users.
This tutorial explains how to install Redis Exporter, configure Prometheus to scrape Redis metrics, visualize them in Grafana, and set up alert rules for Redis, providing step‑by‑step commands, configuration snippets, and screenshots for a complete monitoring solution.
This article explains how to improve large‑file upload experiences by using instant transfer (MD5‑based deduplication), chunked upload, and resumable upload techniques, and provides complete Java backend implementations with Redis coordination and code examples using RandomAccessFile and MappedByteBuffer.
Redis officially announced that starting with version 7.4 it will abandon the BSD 3‑Clause license and adopt a dual SSPLv1/RSALv2 source‑available model, while keeping the community edition free for developers and assuring no changes for existing users or client libraries.
This article details DeWu's self‑built high‑performance distributed Redis cache system, covering its Proxy‑based architecture, core components like ConfigServer, Redis‑Proxy and Redis‑Server, the automated operations platform for deployment and scaling, as well as monitoring, alerting, stability measures and future roadmap.
This article provides a comprehensive overview of Redis' eight common data structures—including String, List, Hash, Set, Sorted Set, Bitmap, HyperLogLog, and Geospatial—detailing their internal implementations, core commands, practical code examples, and typical application scenarios for developers.
This article explains how to integrate Lua scripts into Spring Boot applications using Redis, covering Lua basics, advantages of Lua in Redis, practical use cases, step‑by‑step implementation with code examples, performance optimization, error handling, security considerations, and best practices for reliable backend development.
This article analyzes the shortcomings of fragmented monitoring systems, defines key metrics such as MTTA and MTTR, proposes a unified alert convergence architecture using Redis delayed queues, and details design, implementation, and future AI‑enhanced improvements to reduce alert fatigue and accelerate incident response.
This article dissects Redis's memory architecture, explains each memory component, walks through object encoding rules, buffer handling, fragmentation, and child‑process memory, then presents two production incidents with step‑by‑step analysis and concrete optimization actions to prevent future memory alarms.
The article explains why data inconsistency occurs between MySQL and Redis under high concurrency, analyzes cache‑delete timing issues, and presents two solutions—delayed double‑delete and asynchronous cache updates via MySQL binlog—detailing implementation steps, advantages, drawbacks, and practical considerations.
This article analyzes multiple engineering solutions for automatically cancelling orders after the payment timeout, covering single‑machine and cluster scheduled‑task designs (Quartz, ElasticJob, XXL‑JOB), delayed‑message techniques (RocketMQ, custom delay service, Redis), and essential concurrency and monitoring best practices.
This article provides a comprehensive overview of Redis, covering its core concepts, deployment architectures—including single instance, high‑availability, Sentinel, and cluster setups—its replication mechanisms, gossip protocol, and the various persistence options such as RDB, AOF, and fork‑based snapshots.
This article introduces HertzBeat, an open‑source real‑time monitoring and alerting system that offers powerful template‑based monitoring without agents, explains its Docker‑quick start, demonstrates how to monitor Redis and SpringBoot services, and walks through email alarm configuration.
The article explains the concepts of cache penetration, cache breakdown, and cache avalanche, illustrates why they cause massive database load, and provides practical mitigation techniques such as parameter validation, storing null placeholders, Bloom filters, rate limiting, hot‑key pre‑warming, distributed locking, and cache pre‑warming strategies, with Java code examples.
This article walks through the problem of implementing a reliable Redis distributed lock in Go, explains the pitfalls of naive SetNx usage, introduces timeout handling and GetSet replacement, provides step‑by‑step Go code, and demonstrates its correctness with a multithreaded test.
The ioredis author @Luin announced the library's acquisition by Redis Inc., recounting its nine‑year evolution from a personal side project created to address missing Promise support, aesthetic command syntax, and lacking Cluster/Sentinel features into the most popular Node.js Redis client today.
This article explains the concept of delayed tasks, distinguishes them from scheduled tasks, and presents six practical Java implementations—including Quartz database polling, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets, Redis key‑space notifications, and RabbitMQ delayed queues—along with their advantages and drawbacks.
This article explains what constitutes a large Redis key, the performance problems it can cause such as CPU spikes, client timeouts and memory imbalance, and presents practical solutions including key cleanup, splitting, compression, pipeline usage, and alternative storage options.
The ioredis author announced its acquisition by Redis, detailing the library's evolution from a personal side project to the leading Node.js Redis client, its technical advantages over earlier libraries, and providing links to the new repository and author’s profile.
The article explains what cache penetration is, why it can crash databases under malicious traffic, and presents practical mitigation techniques such as Bloom filters, null-value caching, data pre‑warming, and request validation to protect Redis‑backed systems.
This article explains how a high‑throughput, low‑latency flight search system handles billions of daily requests by employing multi‑level caching, distributed Redis and MongoDB stores, AI‑driven TTL optimization, and advanced load‑balancing techniques such as pooling and overload protection.
To ensure the massive, multi‑platform membership service remains fast and reliable, this article details a multi‑center architecture using Elasticsearch for unified member data, Redis caching, and MySQL partitioning, along with traffic isolation, fault‑tolerant syncing, and fine‑grained flow‑control and degradation strategies.
ioredis, a high‑performance Node.js Redis client created by luin, uses a single‑socket pipeline for efficient command batching, has attracted enterprise users like Alibaba, and after years of growth was officially acquired by Redis, with its source now hosted on GitHub.
This article introduces Redis's five extended data types—Stream, Geospatial, Bitmap, Bitfield, and HyperLogLog—explaining their concepts, common commands, and practical code examples, and highlights how they address specific internet‑scale scenarios more efficiently than traditional relational solutions.
The ioredis project, a robust Node.js Redis client created by Luin to address shortcomings in existing libraries, has been acquired by Redis Ltd, with its repository moved under the official Redis organization, highlighting its nine‑year evolution from a personal side project to a leading open‑source database client.
This article explains three practical Spring Boot approaches—scheduled tasks, delayed RabbitMQ queues, and Redis key‑expiration events—to automatically cancel orders that remain unpaid for 30 minutes, complete with ready‑to‑use Java code examples.
This article explains what a distributed ID is, outlines its essential requirements such as global uniqueness, high performance, high availability, and ease of use, and then reviews common generation strategies—including database auto‑increment, segment mode, NoSQL approaches, UUID, Snowflake, and several open‑source frameworks—providing code examples and practical trade‑offs.
This article explains Redis's five basic data types—String, List, Hash, Set, and Sorted Set—detailing their typical use cases, common commands, and providing concrete CLI examples that demonstrate how to manipulate each type.
This article introduces J2Cache, a two‑level caching framework for Spring Boot, explains its L1 (Caffeine/Ehcache) and L2 (Redis/Memcached) architecture, and provides a complete hands‑on example covering Maven dependencies, configuration, core service classes, REST controller, and testing procedures.
This article explains why a custom business risk‑control (rate‑limiting) component is needed for AI‑intensive services, compares open‑source solutions, and provides a complete backend implementation using Redis+Lua scripts, Kotlin code, Spring AOP annotations, and real‑time adjustable rules.
This article explains how to integrate Lua scripts into Spring Boot applications using Redis, covering Lua fundamentals, advantages of Lua in Redis, practical use cases, step‑by‑step implementation, performance optimization techniques, error handling, security considerations, and best practices for reliable backend development.
This article presents a step‑by‑step technical walkthrough of a SpringBoot‑based Seckill project, covering password MD5 hashing, distributed session management, unified exception handling, page and object caching, static page generation, memory flag with Redis pre‑decrement and RabbitMQ async processing, oversell prevention, and API rate limiting, followed by a visual demonstration of the system’s UI and source code download.
This article provides a comprehensive overview of distributed locks, detailing their four essential conditions, three implementation methods—including a Redis-based solution with Java code examples—and explains how to acquire and release locks safely in high‑concurrency distributed systems.
This article reviews eight popular distributed ID generation methods—including UUID, database auto‑increment, Redis INCR, Snowflake, database segment, Meituan Leaf, Didi Tinyid, and Baidu UidGenerator—detailing their principles, code examples, advantages, disadvantages, and practical considerations for choosing the right solution.
This article explains the classic cache consistency problem between MySQL and Redis, analyzes why inconsistencies occur, and details four common design patterns—delete‑then‑update, update‑then‑invalidate (Cache‑Aside), Read/Write‑Through, and Write‑Behind—along with their advantages, drawbacks, and typical execution flows.
A week‑long API freeze in a sandbox environment was traced to Redis connection pool misconfiguration, where threads waited indefinitely for a Jedis resource, leading to Tomcat request threads blocking and 500 errors, and the issue was resolved by adjusting pool settings and using proper connection release patterns.
This article compares Redis Streams and Kafka, examining their architectures, ordering guarantees, consumer group models, scalability, and trade‑offs, and shows how Redis can emulate Kafka‑like semantics using the Runnel library, while highlighting memory‑speed benefits versus Kafka’s durable, unlimited log storage.
Discover ten practical Redis scenarios—from counting page visits and caching category trees to implementing distributed locks, leaderboards, rate limiting, bitmap analytics, message queues, and global ID generation—each illustrated with concise code snippets and best‑practice tips for robust backend development.
This article details Qunar.com's Redis automation operations system, covering background challenges, the high‑availability cluster architecture, resource management, automated deployment, various migration strategies, scaling mechanisms with RedisGate, inspection processes, and future AI‑driven enhancements.
This article walks through the fundamentals of HTTP session handling, the challenges of session sharing in clustered environments, and presents a step‑by‑step design of a Single Sign‑On solution using CAS, including concrete code examples, Redis‑based session storage, and a comparison with OAuth2.
This article presents sixteen practical Redis use cases—including caching, distributed locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow relationships, and leaderboards—each explained with data types, commands, and code examples.
This article explains why distributed locks are needed, outlines Redisson's lock properties, walks through its Lua‑based acquisition, renewal, and release processes, examines master‑slave pitfalls, compares RedLock with Zookeeper, and provides practical code examples for Java developers.
This tutorial explains how to add Redis dependencies to a Spring Boot project, configure connection settings, use RedisTemplate for basic operations, enable Spring Cache, employ Redisson for distributed locks, and fine‑tune connection pool and timeout parameters, providing complete code examples.
This article explains how to integrate Lua scripts into Spring Boot applications using Redis, covering Lua fundamentals, performance benefits, practical use cases, step‑by‑step implementation, error handling, security considerations, and best practices for optimizing backend services.
This article introduces Redis as an in‑memory key‑value data‑structure server, explains its primary use cases, walks through deployment options such as single instances, high‑availability, Sentinel and Cluster, and details its persistence mechanisms including RDB, AOF and forking.
Learn how to seamlessly integrate Spring Data Redis Repositories in a Spring Boot 2.7 environment, covering object mapping, CRUD operations, indexing with @Indexed, query‑by‑example, batch saves, and setting expiration using @TimeToLive, complete with code examples and visual data representations.
The article explains why the KEYS command can freeze a Redis instance with millions of keys, analyzes its O(n) blocking behavior, and demonstrates how the incremental SCAN command with cursor, MATCH, and COUNT parameters provides a non‑blocking alternative for retrieving prefixed keys.
This guide demonstrates how to use Spring Boot 2.7 with Redis 6.2 to implement Pub/Sub messaging, transactional operations, pipelined commands, and Lua‑based distributed locks, providing code examples, configuration details, and explanations of each feature’s advantages and limitations.
This article explains the relationship between MySQL and Redis, the classic cache‑consistency problem, and compares four common cache‑update patterns—delete‑then‑update, update‑then‑invalidate, read/write‑through, and write‑behind—detailing their workflows, advantages, and drawbacks.
This course offers an in‑depth exploration of process concepts, TCP/IP and Socket communication, Nginx‑FASTCGI integration, host‑to‑network byte order conversion, and Redis fundamentals, targeting backend developers, system administrators, and network engineers seeking comprehensive backend skill enhancement.
This article explains the concept of idempotency, identifies which API requests are naturally idempotent, discusses why idempotency is essential for retries, asynchronous callbacks, and message queues, and provides a step‑by‑step Java Spring implementation using custom annotations, AOP, and Redis for token management.
This article explains the problems of traditional session management in multi‑service environments, introduces session replication and centralized storage (using Redis), and demonstrates a complete CAS‑based single sign‑on solution with Java code examples for user, controller, filter, and configuration components.
This article details the design and implementation of a highly available membership system that handles billions of users and peak traffic of over 20,000 TPS, covering Elasticsearch dual‑center master‑slave clusters, traffic‑isolated three‑cluster architecture, Redis caching with distributed locks, and dual‑center MySQL partitioning.
This guide introduces Lock4j, a versatile distributed‑lock component for Java that works with Spring AOP and supports RedisTemplate, Redisson, and Zookeeper, and walks through its features, configuration, annotation attributes, basic usage, and advanced customization options.
This article introduces KeyDB, a high‑performance multithreaded fork of Redis, explaining its architecture, thread model, connection management, fastlock mechanism, and active‑replica features, while providing code examples and performance comparisons, and highlighting their impact on throughput and latency.
This guide explains Redis's three clustering modes—master‑slave, Sentinel, and Cluster—detailing their architectures, failover mechanisms, PSYNC replication, configuration files, Spring Boot integration, and step‑by‑step testing to achieve high availability and scalability.
Bloom filters are space‑efficient probabilistic structures that test set membership using multiple hash functions, offering fast, low‑memory checks with a controllable false‑positive rate, and can be implemented manually in Java, via Guava’s library, or deployed at scale with RedisBloom for distributed applications.
The article shows how to build a reliable Redis‑based distributed lock in a Spring Boot 2.7 application by storing a unique UUID token, acquiring the lock with SET NX PX, releasing it atomically via a Lua script, and providing a clean Lock interface, factory component, and JUnit example.
This article provides a comprehensive technical overview of Redis, covering its high‑performance in‑memory design, rich data structures, persistence options, transaction support, eviction policies, common caching patterns, distributed locking techniques, and high‑availability solutions such as Sentinel and Cluster, while also comparing it with alternatives like Memcached, Tair, Guava, EVCache and ETCD.
This article explores high‑performance cache design, illustrating concepts with real‑world analogies, detailing traditional and multi‑level caching architectures, and providing practical implementations using Redis, Caffeine JVM cache, OpenResty Nginx local cache, and synchronization strategies such as double‑write, async notifications, and Canal‑based data replication.
This article explains why cache inconsistency occurs between MySQL and Redis, then walks through four concrete design patterns—delete‑then‑update, update‑then‑invalidate, read/write‑through, and write‑behind—detailing each step, trade‑offs, and failure scenarios to help engineers choose the most suitable approach.
This article explains how to build a TCC‑style distributed transaction layer for Redis using Go, detailing the two‑phase commit workflow, handling of prepare, commit, and rollback phases, the associated consistency challenges, and providing full code examples.
This article explains why request debounce is essential for preventing duplicate submissions, outlines which APIs need protection, and walks through two distributed‑lock solutions—shared Redis cache and Redisson—showing concrete annotations, key‑generation logic, and Spring‑AOP code with full test results.
This article demonstrates how to implement API request throttling in a Spring Boot application using a custom Interceptor and Redis, covering basic principles, configuration, custom annotations, reflection for per‑endpoint limits, handling path parameters, and addressing timing logic nuances.
This article explains the relationship between MySQL and Redis, discusses why cache consistency is challenging, and details four cache update design patterns—delete‑then‑update, update‑then‑invalidate, read/write‑through, and write‑behind—along with their advantages, drawbacks, and typical execution flows.
This article demonstrates how to build a Spring‑based API rate‑limiting solution using an Interceptor and Redis, covering the basic principle, project setup, code implementation, custom annotation with reflection for flexible limits, handling path‑parameter keys, real‑IP acquisition, and practical considerations for production use.
This article walks through creating a functional Redis service called EasyRedis, focusing on implementing a distributed cluster with a consistent‑hash algorithm in Go, including detailed code examples, node mapping, command routing, and relay mechanisms.
This article walks through the design and Go implementation of a reusable Redis connection pool, covering the pool data structure, object acquisition and release logic, handling of active limits and waiting queues, and an extended per‑IP socket pool for distributed Redis clusters.
This article provides a comprehensive tutorial on installing RedisInsight, configuring its environment variables, running it as a service or in Kubernetes, and using its GUI features to monitor and manage Redis instances, complete with code examples and deployment YAML.
Redis distributed locks require unique identifiers, atomic Lua releases, and TTL refreshes to avoid deadlocks, while the Redlock algorithm adds majority quorum but remains vulnerable to clock drift and client pauses, so critical systems should combine it with fencing tokens or version checks for true safety.
This article walks through building a functional Redis server in Go, focusing on transaction support (MULTI, EXEC, WATCH, UNWATCH, DISCARD), using locks for atomicity, version tracking for watch, and an undo‑log mechanism for rollback, with code examples and demo screenshots.
This guide walks through implementing a two‑level cache in Spring Boot 2.7 using Lettuce’s CacheFrontend together with Caffeine, covering dependency setup, configuration, custom CacheAccessor, bean definitions, and sample endpoints that demonstrate automatic synchronization and eviction between local JVM cache and Redis.
The article explains how to use Redis Sorted Sets for efficient pagination, employ Hashes with HSCAN for multi‑condition fuzzy matching, combine both techniques into a unified solution, and apply expiration‑based optimizations to keep the cache lightweight and responsive.
This article demonstrates how to replace heavyweight Spring Security with the lightweight Sa-Token framework by configuring token generation, session storage in Redis, service discovery via Nacos, and permission checks in a Spring Cloud Gateway micro‑service architecture, complete with code examples and deployment settings.
This article explains Lua fundamentals, why Lua is advantageous inside Redis, common use‑cases such as cache updates and distributed locks, and provides step‑by‑step guidance for integrating and executing Lua scripts in a Spring Boot application to improve performance and ensure atomicity.
This comprehensive guide walks through Redis's core data structures—including strings, lists, sets, sorted sets, hashes, HyperLogLog, bitmaps, streams, and geospatial indexes—explaining their characteristics and providing concrete command‑line examples to help developers select and use the right structure for their applications.
This article introduces Redis fundamentals and demonstrates how to integrate Redis into PHP web applications for caching, session management, database caching, and queue operations, providing code examples that illustrate connecting to Redis, setting and retrieving data, and configuring expiration to boost performance and stability.
This guide introduces RedisInsight, a powerful GUI for Redis, outlines its key features such as cluster support, visual data browsing, built‑in CLI, stream and log analysis, and provides step‑by‑step installation instructions for Linux, Kubernetes, and macOS, plus basic usage tips.
This guide introduces RedisInsight, outlines its key features, provides step‑by‑step installation on a physical server and via Kubernetes, explains environment configuration and startup, and demonstrates basic usage for monitoring and managing Redis instances through its graphical interface.
This article walks through the complete process of implementing a custom login authentication in Spring Boot, including custom authentication filters, success/failure handlers, a token stored in Redis, role‑based URL security, and detailed configuration of Spring Security headers and session handling.
This article analyzes why Lettuce's mget on Redis Cluster performs poorly due to slot-based architecture, presents client-side refactoring using hashtags and pipeline‑based JedisCluster modifications, and shows benchmark results demonstrating up to double speed improvement over Lettuce.
In his first 2024 blog post, Redis founder antirez shares a programmer's perspective on large language models, sharply critiques Google's search engine, evaluates current AIGC as both foolish and historically knowledgeable, and argues that generative AI mainly amplifies the abilities of already strong developers.
This article explains cache prewarming—its purpose, benefits, and various strategies such as startup loading, scheduled tasks, manual triggers, and cache loaders—while providing concrete Spring Boot and Redis examples, including code snippets for ApplicationReadyEvent, CommandLineRunner, InitializingBean, @PostConstruct, @Scheduled, and Caffeine cache loader.
This article explains why Redis traditionally operates with a single thread, how its memory‑centric design, simple data structures and I/O multiplexing keep it fast, and why newer Redis versions introduced multithreading for network I/O and lazy deletion of large keys.
This article covers Java backend architecture fundamentals, including front‑end/back‑end separation, Maven configuration, distributed lock implementations with Redis and Zookeeper, session handling in distributed systems, database locking strategies, and useful code snippets for common patterns.
A sudden Redis outage caused a shopping homepage to take 20 seconds to load, prompting a rapid analysis of data‑volume growth, a post‑mortem of the fallback logic, and the design of a combined local‑cache, MongoDB, and database strategy to restore fast, reliable service.
This article explains how to prevent API abuse by using a Spring Interceptor combined with Redis to count requests per IP and URI, demonstrates step‑by‑step code implementations, discusses custom annotations, mapping rules, time‑window challenges, path‑parameter handling, and real‑IP extraction for robust backend rate limiting.
This article reveals the most common Redis pitfalls—including unexpected key expiration loss, O(1) commands that block or cause OOM, master‑slave synchronization quirks, and persistence bugs—while providing practical guidance to avoid each issue and keep your cache performant and reliable.
The article analyzes the inventory oversell problem caused by concurrent purchase requests and presents four backend solutions—including a Redis distributed lock, MySQL row lock, optimistic locking with version fields, and conditional SQL updates—illustrated with Java code and SQL examples to ensure data consistency.
This article explains Redis's two persistence mechanisms—Append Only File (AOF) and RDB snapshots—detailing their operation, advantages, risks, write‑back strategies, rewrite process, and how to choose the appropriate method for performance and reliability requirements.
This article walks through implementing a Redis‑compatible sorted‑set in Go, covering requirement analysis, data‑structure design with a map and skiplist, detailed insertion and search algorithms, complete code examples, and edge‑case handling, all illustrated with diagrams and sample output.
This article explains two API rate‑limiting strategies—fixed‑window using Redis keys and sliding‑window using Redis sorted sets—detailing their principles, drawbacks, and providing complete Java implementations with Lua scripts, AOP annotations, and Redis configuration to enforce request limits.
