This article explains how Redis uses RDB snapshots, the AOF write‑ahead log, copy‑on‑write forked processes, and configurable fsync policies to achieve rapid recovery after crashes while balancing performance and data safety.
This article explains the Redisson library’s distributed lock implementation in Java, covering its basic concepts, custom lock creation with Lua scripts, reentrant and fair lock mechanisms, the watchdog renewal process, and practical usage examples with code snippets.
This comprehensive guide explains why distributed locks are needed, outlines their three essential properties, compares common implementations such as Redis, MySQL, ZooKeeper, and Redlock, discusses pitfalls like non‑atomic operations and lock expiration, and presents correct patterns using atomic commands, Lua scripts, watchdogs, and fencing tokens.
This article explains how to size Redis memory, configure maxmemory and maxmemory‑policy, and details the various eviction strategies—both non‑eviction and eviction policies—while describing the inner workings of Redis's LRU and LFU algorithms and their practical trade‑offs.
The article surveys Go‑based distributed ID generation techniques—from UUID, short‑UUID, XID, KSUID, ULID, and Snowflake to database auto‑increment, Redis, ZooKeeper, and segment/leaf approaches—detailing their characteristics, trade‑offs, implementation snippets, and strategies for ordering, uniqueness, and clock‑rollback handling.
This article explores the architecture and implementation of a high‑concurrency ticket‑snatching system, covering load‑balancing strategies, Nginx weighted round‑robin configuration, Redis‑based inventory management, and Go code examples that together enable handling millions of simultaneous requests while preventing overselling and ensuring high availability.
The article examines the open‑source Dragonfly memory cache, its performance claims versus Redis, the Redis team's rebuttal, detailed benchmark methodology, results across GET/SET workloads, and the architectural principles that keep Redis competitive in real‑time in‑memory data storage.
This article explains why delayed queues are needed for scenarios like unpaid orders or auto‑generated comments, compares built‑in and third‑party solutions, and provides a detailed design and implementation guide for a Redis‑based delayed‑queue service, including version‑1.0 features, version‑2.0 optimizations, and multi‑node deployment.
This article explains the business scenarios that require delayed processing, compares several delay‑queue solutions such as Java's DelayQueue, RocketMQ and RabbitMQ, and then details a custom Redis‑backed delayed‑queue architecture (1.0 and 2.0 versions) with Zookeeper coordination, pull‑job and worker threads for high‑availability and real‑time message delivery.
This article compares two approaches for keeping MySQL and Redis in sync—using MySQL triggers combined with a UDF to write directly to Redis, and parsing MySQL binlogs (e.g., with Alibaba's Canal) to propagate changes—detailing their workflows, advantages, limitations, and implementation details.
This article explains how Redisson implements distributed locks on Redis, covering basic lock concepts, custom Lua scripts for lock acquisition and release, re‑entrant behavior, the automatic lock‑renewal watchdog, and the design of a fair lock using Redis lists and sorted sets.
This article explains how to achieve efficient large‑file uploads by using instant (MD5‑based) transfer, chunked uploading, and breakpoint resume, detailing the underlying Redis logic, server‑side Java implementations with RandomAccessFile and MappedByteBuffer, and practical deployment considerations such as file servers and OSS.
This article provides a comprehensive guide to Redisson's distributed lock implementation in Java, covering its architecture, basic and reentrant lock mechanisms, fair lock using Redis lists and sorted sets, lock renewal via watchdog, and detailed code examples with Lua scripts.
This article explains the challenges of distributed session management in microservice architectures and presents four solution approaches, focusing on a Java implementation using Spring Session with Redis, including dependency setup, configuration, login logic, controller handling, and verification through testing.
This article walks through practical Go implementations of Redis list commands—including LPush, RPush, LLen, LRange, and others—provides unit test examples, demonstrates a simple performance benchmark, and shares a reusable wrapper library for streamlined backend development.
This guide explains how to use Redis Bitmap to efficiently store and query massive binary state data—such as user login status and daily sign‑ins—by leveraging GETBIT, SETBIT, BITCOUNT, BITPOS, and BITOP commands, dramatically reducing memory usage for millions of users.
This article examines the open‑source Dragonfly memory cache, compares its performance and architecture against Redis using reproducible benchmarks on AWS c6gn.16xlarge instances, and discusses the implications of the results for future in‑memory data store designs.
The article explains the need for delayed processing in business scenarios, compares various delayed queue solutions such as Java DelayQueue, RocketMQ, and RabbitMQ, and details a Redis-based implementation with message storage, ZSET queues, pull jobs, workers, and Zookeeper coordination for high availability.
This article examines common distributed ID generation strategies—including UUID, Snowflake-like algorithms, database auto‑increment, and Redis atomic increment—detailing their requirements, advantages, drawbacks, and suitable scenarios to help engineers select the most appropriate solution for high‑performance, secure systems.
This article explains how Redisson implements distributed locks on Redis, covering basic concepts, differences from Jedis and Lettuce, the Lua scripts for lock acquisition, reentrancy handling, automatic lease renewal via a watchdog, Pub/Sub based unlock notifications, and the design of a fair lock using Redis lists and sorted sets.
This article presents a comprehensive design and implementation of a high‑concurrency train‑ticket flash‑sale system, covering distributed architecture, load‑balancing strategies, Nginx weighted round‑robin configuration, Go‑based services, Redis‑backed stock management, and performance testing results.
Redis achieves high performance by storing all data in memory, using compact data structures such as SDS, ziplist and skiplist, running a single‑threaded event loop with lock‑free execution, and employing efficient I/O multiplexing and incremental rehash techniques to minimize latency and maximize throughput.
This article details the JD.com delivery review system's business scenarios, architectural evolution from a MySQL‑based design to a diversified storage stack using HBase, Redis, Elasticsearch and TiDB, and discusses the performance challenges, solutions, and future outlook for scalable, high‑availability data management.
This article demonstrates how to create a simple lottery application using Spring Boot, MyBatis‑Plus, and Redis, covering project setup, database schema, dependency configuration, Redis integration, event‑driven data initialization, lottery draw logic, stock management, and asynchronous record handling.
Redis achieves high performance by storing all data in memory, using compact data structures such as SDS, hash tables, skip‑lists and zip‑lists, running a single‑threaded event loop with I/O multiplexing, and applying optimisations like lazy‑free, progressive rehashing and optional multi‑threaded I/O for network traffic.
RedisInsight is a powerful GUI for Redis that supports cluster management, SSL connections, and memory analysis; this guide walks through downloading, installing on Linux, configuring environment variables, running as a service, deploying via Kubernetes, and using the web UI to monitor and operate Redis instances.
This article explains Redisson's in‑memory data grid features, compares it with Jedis and Lettuce, and walks through the implementation of re‑entrant, watchdog‑enabled, and fair distributed locks using Redis Lua scripts and Java code examples.
The article explains why caching is essential for high‑traffic read‑heavy services, analyzes the consistency problems that arise when data exists simultaneously in MySQL and Redis, compares four cache‑update strategies, and provides practical recommendations such as using expiration, delayed double‑delete, message queues, and binlog subscription to achieve eventual consistency.
This article shares several practical coding techniques for backend development, including how to commit Kafka transactions safely, simplify Redis distributed lock usage with Redisson, implement AOP-based method locking, and decouple business logging using thread pools and asynchronous processing.
The article analyzes why a coupon‑distribution feature can issue more coupons than available under heavy load, explains the root cause of concurrent stock deductions, and presents four practical solutions—including Java synchronized blocks, SQL row‑level locking, Redis distributed locks, and Redisson—to reliably prevent over‑issuance.
This article shares practical development techniques, including how to safely commit Kafka messages within transactions, simplify Redis distributed locks with Redisson, implement an AOP‑based lock annotation for method-level locking, and decouple business logging using asynchronous thread pools and helper utilities.
The article explains the concept of interface call idempotency in distributed micro‑service architectures, outlines scenarios that cause idempotency problems, and presents practical solutions such as token mechanisms, various lock strategies, unique constraints, deduplication tables, and global request IDs, with code examples in Java and Redis.
This article explains traditional HTTP session handling, the problems of session sharing in clustered environments, two common session‑sharing strategies, and introduces single sign‑on (SSO) concepts with a detailed CAS‑based implementation using Spring Boot, Redis, and Java filters.
This article explains the concepts and implementation details of instant (秒传) upload, chunked (分片) upload, and breakpoint resume upload, providing Java backend code using Redis, RandomAccessFile, and MappedByteBuffer to achieve efficient large‑file transfer with MD5 deduplication and progress tracking.
This article explains traditional session and authentication mechanisms, the problems of session sharing in clustered and multi‑service environments, and presents practical SSO solutions—including CAS‑based single sign‑on and its differences from OAuth2—accompanied by complete Java Spring code examples.
Redis can be used to create a distributed lock by storing a unique key-value pair with an expiration time, and Redisson enhances this with a watchdog mechanism that automatically renews the lock, handling lock acquisition, expiration, and release through Lua scripts and subscription-based waiting.
This article explains how to build a high‑concurrency ticket‑seckill service that can handle millions of requests by combining distributed load‑balancing (OSPF, LVS, Nginx weighted round‑robin), a pre‑deduction stock strategy using local memory and Redis with Lua scripts, and a Go‑based HTTP server, and it demonstrates performance testing results.
This article explains the challenges of multiple system logins, reviews traditional HTTP session handling, presents session sharing solutions like replication and Redis‑based central storage, and details a CAS‑based single sign‑on implementation with code examples, while also comparing CAS to OAuth2.
The Vivo Internet Server team built a Redis‑based pseudo‑message queue that uses per‑game fixed‑length lists, a global game set, and Lua scripts for atomic batch production and consumption, satisfying 128‑behavior batch limits, three‑minute timeliness, and high‑throughput (≈10 k QPS) requirements.
This article explains how Redis internally stores set and sorted‑set objects using intset, hashtable, ziplist, and skiplist encodings, the conditions that trigger each representation, the upgrade process, and the essential Redis commands for manipulating these data structures.
This article surveys common delayed‑message implementations—including external storage, RocksDB, Redis, and open‑source MQs like RocketMQ, Pulsar, and QMQ—detailing their architectures, advantages, disadvantages, and practical considerations for distributed asynchronous messaging systems.
This article surveys common delayed‑message solutions in distributed asynchronous messaging, evaluates implementations based on external storage, databases, RocksDB, Redis, and open‑source MQs like RocketMQ, Pulsar and QMQ, and discusses their advantages, drawbacks, and practical design considerations.
This article explains why unified authentication is essential for product suites, reviews traditional session mechanisms and their limitations in clustered environments, explores session‑sharing strategies, introduces CAS‑based SSO workflows, compares CAS with OAuth2, and provides a complete Spring Boot demo with code snippets and configuration details.
When expired keys accumulate and lazy deletion can't keep up, Redis relies on configurable memory eviction policies and proper maxmemory settings, and selecting the appropriate strategy along with an optimal cache size (typically 15‑30% of total data) ensures stable performance and avoids out‑of‑memory errors.
This guide walks you through installing RedisInsight on Linux, configuring its environment variables, running it as a background service, deploying it on Kubernetes with a ready‑to‑use YAML, and using its UI to monitor Redis metrics, browse and edit data, and analyze memory usage.
This article explains the concept of idempotency in computing and HTTP, why it is essential for APIs, the impact on system design, which RESTful methods are idempotent, and presents four practical implementation strategies—including database primary keys, optimistic locking, anti‑repeat tokens, and downstream sequence numbers—accompanied by complete Spring Boot code examples and testing procedures.
This article walks through three progressive implementations for handling intricate e‑commerce search filters—starting with a raw SQL approach, then optimizing with indexed queries and split statements, and finally leveraging Redis sets and sorted sets for caching, pagination, and high‑performance query execution.
This article explains the concept of idempotency, why it matters for HTTP APIs, compares the idempotent characteristics of RESTful methods, and presents four practical implementation strategies—including database primary keys, optimistic locking, Redis‑based tokens, and downstream sequence numbers—along with complete Spring Boot code examples and testing guidance.
This article surveys common delayed‑message solutions—including database, RocksDB, Redis, and open‑source MQs like RocketMQ, Pulsar, and QMQ—explaining their architectures, advantages, drawbacks, and practical considerations for building reliable distributed asynchronous messaging.
The article explains the principles, requirements, and common implementations of distributed lock services using Redis and ZooKeeper, analyzes their drawbacks, and introduces SharkLock's design choices—including lock metadata, reliability via SharkStore, dead‑lock prevention, safety mechanisms, and Raft‑based consistency—to guide developers in building robust distributed locking solutions.
This article examines four strategies for handling session data in distributed backend systems—session replication, client-side storage, hash-based load balancing, and centralized storage with Redis—detailing their principles, advantages, disadvantages, and practical recommendations for different deployment scales.
This article explains why single‑node Redis suffers from single‑point failures, describes the master‑slave replication model, details the Sentinel automatic failover mechanism, compares various sharding solutions like client‑side sharding, Twemproxy, Codis, and outlines the features and deployment considerations of Redis Cluster.
This article explores the architecture, load‑balancing strategies, and Go‑based implementation of a high‑concurrency ticket‑sniping system that can handle millions of simultaneous requests while preventing overselling and ensuring high availability.
This article compares delayed tasks with scheduled tasks, explains their differences, and presents five practical Java solutions—including database polling, JDK DelayQueue, Netty time wheel, Redis implementations, and RabbitMQ—detailing each approach's design, code examples, advantages, and drawbacks.
This article explains how to design and implement a precise, persistent, and retry‑capable delay queue using Redis ordered sets and Lua scripts, provides a complete Go library with usage examples, and discusses the underlying data structures, atomic operations, and garbage‑collection mechanisms.
This article analyzes the coupon over‑issuance issue caused by concurrent requests, demonstrates how simple SQL updates can fail under load, and presents four solutions—including Java synchronized blocks, SQL row‑level locking, optimistic locking, and Redis‑based distributed locks with Redisson—to ensure atomic coupon allocation.
This article explains JD's design of a billion‑scale vehicle‑part matching cache, detailing the data model, bitmap storage structure, SDS pre‑allocation, key‑value compression, cluster routing, and Lua‑based high‑performance search interface that achieves sub‑13 ms latency.
This article explains how Redis stores key‑value pairs, dives into the underlying dict, dictEntry and redisObject structures, and presents seven practical memory‑saving tricks—including key shortening, encoding tweaks, object sharing, bitmap usage, hash consolidation, fragmentation cleanup, and 32‑bit deployment—to dramatically reduce RAM consumption while preserving performance.
This guide walks you through installing RedisInsight on Linux and Kubernetes, configuring environment variables, launching the service, and using its GUI to monitor Redis metrics, edit data, and analyze memory, providing step‑by‑step commands and screenshots for each stage.
This article demonstrates how to create a Java annotation for access limiting, implement the corresponding Spring Boot interceptor that checks Redis counters, register the interceptor in the application, and apply the annotation to a controller method to enforce request rate limits.
This article explains how Redis tackles single‑point failures with master‑slave replication, introduces Sentinel for automatic failover, compares client‑side and proxy sharding solutions like Twemproxy and Codis, and details the native Redis Cluster architecture for true distributed storage and high availability.
This article explains how to build a precise, persistent, and retry‑capable delayed task queue using Redis ordered sets, Lua scripts, and a Go client, addressing common e‑commerce scenarios like auto‑closing unpaid orders and sending activation messages.
This comprehensive guide covers everything from Redis fundamentals, data structures, and thread model to persistence strategies, clustering, memory eviction policies, cache design patterns, and advanced use‑cases like delayed queues, large‑key handling, pipelines, transactions, and distributed locking, providing interview‑ready knowledge for developers.
This article explains Redis's memory model, covering memory statistics, internal structures such as redisObject, SDS, and various object types, their encoding schemes, memory allocation, fragmentation, and provides practical examples for estimating memory usage, optimizing consumption, and monitoring fragmentation in high‑performance applications.
Redis 7.0.3 has been released with medium‑urgency upgrades that improve performance and resource utilization, add new INFO fields and module APIs, enhance CLI clustering support, and fix a range of bugs including TLS handling, cluster failover, and command‑line configuration issues.
This article explains Redis's low‑level data structures—including ziplist, skiplist, intset, quicklist, zipmap and stream—detailing their memory layouts, implementation code, use‑case selection criteria, performance trade‑offs, and configurable parameters that balance speed and space.
This tutorial explains step‑by‑step how to expand a Redis cluster from three masters and three slaves to four masters and four slaves by preparing a new configuration, starting the new instance, and using redis‑cli to add the node and verify slot distribution.
Redis is an open‑source, in‑memory data store that supports various data types, persistence, replication, Sentinel, clustering, Lua scripting, pipelines, and distributed locks, and the article walks through its evolution from simple caching to a high‑availability, horizontally scalable database solution.
This article examines why coupon stock can become negative under concurrent requests and presents four practical solutions—including Java synchronized blocks, SQL conditional updates, Redis distributed locks, and Redisson client usage—to reliably prevent coupon over‑issuance in high‑traffic systems.
The article explains Redis’s internal low‑level structures—ziplist, skiplist, intset, quicklist, zipmap, and stream—detailing their memory‑efficient layouts, operations, use cases, and how they combine (e.g., quicklist merging linked lists with ziplists) to deliver high performance in the in‑memory database.
This article explains the three critical cache failure scenarios—cache penetration, cache avalanche, and cache breakdown—detailing their causes, real‑world impacts on high‑concurrency systems, and practical mitigation techniques using Redis and general backend strategies.
This article explains Spring Boot's caching mechanism based on the JSR‑107 JCache specification, details core interfaces and implementations like Cache, AbstractValueAdaptingCache, and ConcurrentMapCache, demonstrates cache annotations such as @Cacheable, @CachePut and @CacheEvict, and shows how to replace the default in‑memory cache with Redis using Docker, StringRedisTemplate, and custom serialization.
Redis provides multiple high‑availability solutions—including master‑slave replication, Sentinel automatic failover, client‑side sharding, proxy‑based sharding (Twemproxy, Codis), and the native Redis Cluster—each with distinct architectures, advantages, and trade‑offs for scaling, fault tolerance, and operational complexity.
This guide explains how to set up Celery, a distributed asynchronous task framework, to use Redis both as the message broker and result backend, covering project structure, configuration code, task definition, execution, state monitoring, and common control operations.
This article presents a comprehensive solution for building an e‑commerce inventory system that prevents overselling under high concurrency by combining database transactions, Redis‑based stock deduction, idempotent anti‑repeat mechanisms, pipeline optimization, and a task‑engine driven eventual‑consistency architecture.
This article walks through designing three Redis Stream performance test cases—adding, reading, and add‑delete—using dynamic thread and dynamic QPS models in Java, provides complete Groovy‑based test code, and shows sample console output for evaluating throughput and latency.
This article explores the design of a high‑concurrency ticket‑spike system inspired by China’s 12306 platform, covering load‑balancing strategies, distributed stock deduction using Redis, Go‑based HTTP services, weighted round‑robin Nginx configuration, performance testing with ApacheBench, and practical architectural insights for handling millions of simultaneous requests.
This article explores Redis’s internal data structures—including simple dynamic strings, linked lists, and dictionaries—detailing their encoding constants, implementation differences across versions, performance advantages, and rehashing mechanisms that enable high‑throughput, memory‑efficient operations.
This article presents a comprehensive collection of practical Redis scenarios—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, product filtering, recommendation models, and ranking—accompanied by example commands and Java code snippets for each use case.
The article details Redis’s core low‑level data structures—Simple Dynamic Strings (SDS) with length‑aware headers, a custom doubly linked list for O(1) head/tail access, and a hash‑table dictionary employing MurmurHash, incremental rehashing, and packed headers to optimize memory and performance across versions.
This article introduces a Redis lazy‑loading caching strategy combined with Guava local cache, presents design diagrams and Java code examples, analyzes its advantages and disadvantages, and discusses suitable scenarios such as precise query workloads and micro‑service architectures.
This article explains Redis's internal storage mechanisms and presents seven practical optimization techniques—including key‑value compression, small‑collection encoding, object sharing, bitmap usage, hash structuring, memory‑fragment defragmentation, and 32‑bit deployment—to dramatically reduce memory consumption while increasing data capacity.
This article provides a detailed, English-language tutorial on preparing the network environment, creating necessary directories, configuring Redis instance files, launching six Redis nodes, and initializing a clustered Redis deployment across three servers using Linux command‑line tools.
The article explains why common shortcuts such as Redis key‑space expiration notifications, RabbitMQ dead‑letter queues, and non‑persistent time wheels are unreliable for implementing delayed tasks, and recommends using proper message‑queue solutions like RocketMQ, Pulsar, or Redisson DelayQueue with compensation mechanisms.
This technical article explains how to handle millions of simultaneous train‑ticket purchase requests by combining Nginx weighted load balancing, local in‑memory stock deduction, and a centralized Redis stock counter using Go, ensuring no overselling, high availability, and efficient performance.
The article compares five practical approaches for automatically closing unpaid orders—scheduled tasks, RocketMQ delayed messages, RabbitMQ dead‑letter queues, a time‑wheel algorithm, and Redis key‑expiration listeners—detailing their principles, advantages, limitations, and providing concrete Java code examples for each method.
This article explains Redis high‑availability strategies, covering basic hash sharding, the advantages of consistent hashing, client‑side versus proxy‑based partitioning, master‑slave replication, and the Sentinel failover mechanism, with diagrams illustrating node addition, removal, and failover decision processes.
Redis is a single‑threaded, in‑memory data store offering rich structures, configurable expiration, multiple eviction policies, asynchronous master‑slave replication with Sentinel failover, durable RDB snapshots plus AOF logging, and native clustering that shards data across many masters for horizontal scalability and high availability.
This article explains Spring Boot caching by introducing the JSR‑107 JCache specification, detailing core cache interfaces, showing the Spring Cache abstraction and its implementations, demonstrating cache annotations such as @Cacheable, @CachePut and @CacheEvict, and finally covering Redis setup and custom CacheManager usage.
This article explains Redisson's distributed lock mechanism, detailing the lock acquisition, renewal, and release processes, illustrating the design with a flash‑sale example, and providing complete Java code snippets that demonstrate lock handling, spin‑retry, subscription, and Lua script integration.
This article details the evolution of caching architecture from XML-based caching to a multi-level caching system using Protobuf and LocalCache, achieving 70% improvement in API response times.
The article explains why using Redis key‑expiration notifications or RabbitMQ dead‑letter queues for delayed task execution is risky, compares several common approaches, and recommends reliable solutions such as dedicated message‑queue schedulers, Redisson delay queues, or time‑wheel implementations with proper compensation mechanisms.
This article compares three stock‑deduction strategies—single‑field MySQL, sharded MySQL rows, and Redis incrby with Lua scripts—analyzes their concurrency issues, and provides a complete Spring Boot implementation using a distributed lock, Lua script, and callback for initializing stock.
This article examines why using Redis key‑space expiration listeners, RabbitMQ dead‑letter queues, and in‑memory time wheels are unreliable for precise delayed‑task execution, and recommends more robust solutions such as dedicated message‑queue delay features and Redisson DelayQueue with fallback mechanisms.
This comprehensive guide explains Redis's core and newer data types—including String, List, Hash, Set, Zset, BitMap, HyperLogLog, GEO, and Stream—detailing their internal implementations, essential commands, and practical scenarios such as caching, counting, locking, ranking, geolocation, and reliable message queuing.
This article walks through the author’s decision to continue learning Go for Redis access, outlines a step‑by‑step study plan, compares Go and Java Redis clients, presents a custom Go‑Redis wrapper with full source code, demonstrates usage in unit tests, and shares console output observations.
This article explores the importance of rate limiting in distributed micro‑service architectures, explains four core algorithms—fixed window, sliding window, leaky bucket, and token bucket—and details a practical, Redis‑backed multi‑layer throttling solution for a voice‑bot platform, including trade‑offs and implementation tips.
This guide details how to set up Redis Sentinel for high‑availability in a master‑slave architecture, covering configuration file creation, essential sentinel parameters, starting Redis and Sentinel instances, and verifying operation via log inspection.
The article details Guangguang’s shift from a rule‑based, Hive‑driven recommendation pipeline to an algorithmic service that leverages Elasticsearch and Redis for multi‑source recall, coarse and fine model ranking, exposure filtering, cold‑start handling, latency optimizations, reliability monitoring, and future vector‑based enhancements.
This article explains how to combine Redis lazy‑loading caching with Guava local cache to reduce I/O pressure, improve read performance, and balance memory usage, providing code examples, pros and cons, and suitable scenarios for backend and microservice architectures.
