This guide details key Redis monitoring metrics—including performance, memory, activity, persistence, and error indicators—along with practical commands, configuration settings, and code snippets to help operators efficiently track and troubleshoot Redis instances.
This article examines whether Redis can serve as a reliable message queue by exploring its List, Pub/Sub, and Stream data types, comparing their features, performance, and limitations, and ultimately guiding readers on suitable use cases versus professional queue solutions.
This article explains how to design and implement a distributed lock using Redis, Spring AOP annotations, and a scheduled executor to automatically extend lock expiration, providing complete Java code examples, configuration details, testing procedures, and best‑practice recommendations for handling long‑running business operations safely.
This guide explains Redis high‑availability mechanisms, covering master‑slave replication, the Sentinel monitoring and automatic failover process, and the Redis Cluster sharding architecture, including hash slots, MOVED/ASK redirection, gossip communication, and practical considerations such as data consistency, network partitions, and slot allocation.
This article explains the fundamentals of message queues, their typical use cases such as decoupling and traffic shaping, compares implementation options like MySQL, Redis, and dedicated message systems, and provides detailed PHP code examples for flash‑sale and RabbitMQ integrations.
This article walks through the evolution of Redis-based distributed locking—from simple SETNX placeholders and manual expiration, through atomic SETNX EX, UUID‑based lock ownership, Lua‑scripted unlocks, and finally Redisson’s high‑level lock API—highlighting common pitfalls and robust solutions for backend developers.
This article explains how to handle Redis scenarios with oversized keys, massive collections, billions of keys, and large bitmaps or Bloom filters by partitioning data into multiple keys or hashes, using bucketization, multi‑get, and careful bitmap splitting to improve performance and lower memory consumption.
This article explains various backend file upload techniques—including instant (秒传) transfer, chunked (分片) upload, and breakpoint resume—detailing their principles, Redis-based state tracking, and providing Java implementations using RandomAccessFile, MappedByteBuffer, and a slice upload template.
This article describes the layered architecture of Qunar's next‑generation database automation platform, outlines the design goals for secure Agent/Plugin‑Server communication, compares communication and encryption methods, and details the authentication and request flow using symmetric encryption and token‑based security.
This article explains why Redis clusters need distributed metadata, compares centralized and decentralized metadata storage, introduces the epidemic‑style Gossip protocol, and details how Redis Cluster implements Gossip messaging, node discovery, failure detection, and state synchronization through concrete code examples.
This article explains how to size Redis memory, configure maxmemory and maxmemory‑policy settings, and choose among various eviction strategies—including no‑eviction, allkeys‑lru, allkeys‑lfu, and volatile options—while detailing the underlying LRU and LFU algorithms used by Redis.
Shopee’s scalable fund‑routing decision engine combines a configurable Go‑based rule engine with Redis‑backed, Lua‑driven quota control to dynamically match loan orders to external capital providers, enforce multi‑dimensional volume limits, achieve tens of thousands TPS, and provide extensible risk‑management capabilities across markets.
The article explains how Redis cache expiration can cause a request avalanche that overloads databases, and presents mitigation techniques such as semaphore rate limiting, per‑key locking, fault‑tolerant cache rebuilding, and example Java code using Spring and Redis.
The article proposes a three‑step, crowd‑based discount system that decomposes discount elements, pre‑computes fan group membership in Redis, and combines offline batch with real‑time event synchronization, achieving tens of thousands QPS, millisecond latency, and both eventual and strong data consistency.
This article explains how Redis handles key expiration, the three expiration deletion strategies, the eight memory‑eviction policies configurable via maxmemory, and the inner workings of Redis's LRU and LFU algorithms, including sampling, lru_clock, and counter decay mechanisms.
This article compares JWT and session authentication, discusses their differences, security, performance, and lifecycle considerations, and provides a complete Java implementation—including dependency configuration, token utilities, Redis integration, login/logout flows, password updates, and request interception—guiding developers to select the most suitable approach for their projects.
The article evaluates common approaches for implementing delayed tasks such as order‑closing, critiques unreliable methods like Redis expiration listeners and RabbitMQ dead‑letter queues, and recommends robust solutions like RocketMQ, Pulsar, or Redisson delay queues with proper compensation mechanisms.
The article examines three approaches to handling inventory deduction in e‑commerce—single‑field MySQL, sharded MySQL rows, and Redis incrby—analyzes their concurrency drawbacks, and presents a robust Redis‑Lua script solution with distributed locking and Java implementation details.
This article compares JWT and session-based authentication, detailing their differences, advantages, disadvantages, security considerations, performance impacts, and provides a complete Java implementation with token generation, Redis storage, login, logout, password update, and interceptor configuration.
Redis achieves remarkable speed by operating as an in‑memory database, leveraging specialized data structures like SDS, linked lists, hash tables, skip lists, and ziplists, while using a single‑threaded event loop with I/O multiplexing, incremental rehashing, and optimized memory management to minimize latency.
This article explains how to implement fast nearby POI queries by calculating distances with the Haversine formula, designing MySQL tables and indexes, applying GeoHash for dimensionality reduction, and leveraging Redis Geo for high‑concurrency scenarios, while also providing Go code examples for each step.
This article explains why MySQL struggles with large‑scale ranking, introduces Redis sorted sets as a high‑performance alternative, and provides complete Go code examples—including direct command usage and a struct‑based wrapper—to implement, query, and manage ranked data efficiently.
This article explains how to implement a Redis-based distributed lock in Spring Boot using custom annotations, AOP interception, and a scheduled executor to automatically renew lock expiration, providing a complete design, code examples, and testing guidance for handling long-running operations safely.
This article introduces four essential open‑source technologies—Elastic, MariaDB, RabbitMQ, and Redis—explaining their core features, typical use cases such as search, relational data, messaging, and caching, and why they are popular choices for building scalable backend systems.
This article walks through a real‑world incident where a Redis cache big‑key caused service timeouts, explains how to identify the problem using cluster metrics, outlines detection tools and commands, and provides practical steps to delete big keys and prevent future occurrences.
This article explains the design and implementation of a Redis‑based distributed lock using Spring AOP, covering annotation creation, pointcut definition, lock acquisition, automatic renewal via a scheduled thread pool, error handling, and testing to ensure safe concurrent access to critical business data.
This article explains Redis's superior performance by detailing its six underlying data structures—Simple Dynamic Strings, hash tables, ziplist, quicklist, skiplist, and integer sets—covering their implementations, memory optimizations, collision handling, and lookup complexities, with code examples and diagrams.
This article examines the open‑source memory cache Dragonfly, its performance claims against Redis, presents reproduced benchmark results, discusses architectural differences, and outlines Redis’s design principles and testing methodology.
This article walks through Spring Boot 2.3's session auto‑configuration process, detailing how core SessionConfiguration classes are registered, how the appropriate SessionRepository is selected based on store type, and how the SessionRepositoryFilter wraps requests and responses to manage session data with implementations such as Redis.
This article explains traditional HTTP session handling, the problems of session sharing in clustered and multi‑service environments, and presents practical SSO solutions—including session replication, centralized Redis storage, and a complete CAS‑based single sign‑on implementation with Java code examples.
This article explains how Redis stores set and sorted‑set objects using two underlying data structures, details the intset and hashtable encodings, describes the upgrade process with concrete examples, and lists the common commands for manipulating these collections.
This article provides an in‑depth technical guide to Redis, covering its single‑threaded model, core data structures (String, Hash, List, Set, ZSet) with practical commands, persistence mechanisms (RDB, AOF, hybrid), master‑slave replication, Sentinel and cluster architectures, cache eviction policies, memory management, progressive rehash, skiplist implementation, bitmap statistics, and consistency challenges when coupling Redis with MySQL.
Redis achieves high performance by storing all data in memory, using compact data structures like SDS, linked lists, hash tables, skip lists and integer sets, running a single‑threaded event loop, and handling thousands of client connections with efficient I/O multiplexing.
This article explains how to protect time‑consuming business operations by using Redis as a distributed lock together with Spring AOP, covering annotation design, aspect implementation, lock acquisition, automatic renewal via a scheduled executor, and practical testing examples.
This article explains why Redis delivers high query speed by leveraging its in‑memory architecture, custom data structures such as SDS, linked lists, hash tables, skip‑lists, and intsets, a single‑threaded execution model combined with efficient I/O multiplexing, and recent multithreaded I/O enhancements.
The architecture combines a nightly batch job that generates offline user profiles stored in HBase with a Flink‑based stream layer that lazily loads those profiles on app start and creates real‑time updates, then fuses both streams into a unified, timestamp‑ordered profile in Redis, forming a Lambda‑style pipeline.
This article presents a comprehensive Java web application that combines movies, music, and books, built with Spring Boot, MyBatis, Redis, and Nginx, and provides detailed environment specifications, architecture diagrams, feature screenshots, and step‑by‑step deployment instructions.
This article provides an in‑depth technical guide to Redis, covering its single‑threaded I/O model, core data structures (String, Hash, List, Set, ZSet), persistence options (RDB, AOF, hybrid), master‑slave replication, Sentinel, cluster slot allocation, eviction policies, progressive rehash, skip‑list implementation, and consistency challenges between MySQL and Redis.
This article provides an in‑depth overview of Redis, covering its single‑threaded design, core data structures, persistence mechanisms (RDB, AOF, hybrid), master‑slave replication, Sentinel and Cluster architectures, eviction policies, progressive rehash, bitmap usage for massive analytics, skiplist implementation, and strategies for handling MySQL‑Redis write inconsistencies.
This article walks through building a Redis validation tool in Rust, demonstrates how trait objects cause lifetime compilation errors, and shows how to fix them by adding explicit lifetime parameters to structs and implementations.
This article compares a range of Redis visualization solutions—including desktop clients, a web‑based platform, and an IDE plugin—detailing their features, licensing, platform support, and command‑line integration to help developers choose the most efficient tool for their workflow.
This article explains how Redis ensures data durability by describing the two persistence mechanisms—RDB snapshots and AOF append‑only logs—including their creation, loading, configuration options, performance trade‑offs, and guidance on choosing the appropriate method for different workloads.
This article compares JWT and session authentication, explains their differences, outlines the authentication flows, evaluates advantages, disadvantages, security, performance and one‑time use issues, and provides a complete Java implementation with JWT, Redis, interceptor and utility classes.
This article explains why JWT is not ideal for logout and token renewal, recommends using a Redis‑backed token store, and provides three Redis‑based blacklist implementations with detailed Java code snippets for extending JwtTokenStore, custom converters, and global filters in Spring Security OAuth2.
This guide details how to install and configure an NFS server, set up dynamic PersistentVolume provisioning using an NFS StorageClass, and deploy a Redis workload on Kubernetes with appropriate ConfigMaps, PVCs, and Deployment specifications.
This article explains how to reduce Redis read/write pressure by introducing a Guava local cache for lazy loading, presents design diagrams, provides complete Java code examples for both simple lazy caching and a microservice‑oriented device‑increment cache, and discusses the advantages, disadvantages, and practical considerations of each approach.
Redis is an open‑source in‑memory key‑value data‑structure server that serves as a cache, primary database, and messaging system; this article explains its core concepts, deployment options (single instance, HA, Sentinel, Cluster), and persistence mechanisms (RDB, AOF, and hybrid approaches).
This article outlines a comprehensive, cloud‑native rate‑limiting solution using Kong gateway, covering background challenges, design considerations, multi‑layer architecture, plugin development, CI/CD workflow, deployment strategies, and operational best practices to achieve low cost, high efficiency, and high quality across diverse projects.
Redis is an open‑source, in‑memory key‑value store that functions as a data‑structure server, offering caching, replication, high‑availability, clustering, and various persistence options such as RDB snapshots and AOF logs, with detailed deployment models including single instances, Sentinel, and cluster architectures.
Redis caches can fill up, requiring memory eviction; this guide explains how to set Redis maxmemory (e.g., 5GB), choose appropriate eviction policies such as allkeys-lru or allkeys-lfu, and details the underlying LRU and LFU algorithms and their configuration commands.
This article compiles a large set of interview questions frequently asked by top tech companies, covering Java fundamentals, multithreading, Spring framework, MyBatis, Redis, and related concepts, and provides a free QR‑code link for downloading the complete question set with answers.
The article narrates how Redis, personified as a character, discovers data loss risks, implements RDB snapshotting and configurable save intervals, learns from MySQL's binary log, adopts Append‑Only File logging with flush policies, and finally adds AOF rewrite to keep storage efficient.
This article provides a detailed tutorial on Celery, covering its architecture, installation, task structures, basic and advanced usage, integration with Django, and code examples for creating workers, scheduling tasks, and retrieving results, enabling developers to implement robust asynchronous processing in Python applications.
The article explains why interviewers probe the implementation details of backend components such as Redis, HashMap, and Memcached, illustrates common interview questions, and shows how mastering the underlying data structures, algorithms, and memory‑allocation mechanisms can improve both interview performance and real‑world problem solving.
This article explains why Redis stores set and sorted‑set objects using two different internal encodings, describes the intset and hashtable representations for sets, the skiplist and ziplist representations for sorted sets, shows the upgrade process with code examples, and lists the common commands for manipulating these data structures.
The article explains Redis’s core concepts—including its in‑memory key‑value store, six low‑level data structures, single‑threaded execution, AOF and RDB persistence options, master‑replica replication with Sentinel failover, and horizontal scaling via Cluster’s hash‑slot sharding and rebalancing.
This article explains the design and implementation steps for a multi‑active (geo‑distributed) system, covering data‑center segmentation, traffic scheduling, RPC routing, database and Redis sharding, distributed IDs, message queue handling, job coordination, and cut‑over procedures.
This article examines Redis's transition from a single‑threaded reactor to a multi‑threaded I/O model, details the underlying I/O multiplexing and BIO subsystems, and explains the lazyfree mechanism for asynchronous large‑key deletions, providing extensive code analysis and performance insights.
This article provides a comprehensive guide to implementing and testing Go Redis Set APIs—including SAdd, SCard, SIsMember, SMembers, SRem, SPop, and SPopN—complete with code examples, a unified test suite, and a performance benchmark that reports QPS and execution time.
The article explains how to prevent duplicate write requests on the server by using unique request IDs with Redis, computing MD5 digests of business parameters (excluding volatile fields like timestamps), and provides a reusable Java helper class with example code and test logs.
This article explains how to design a Redis‑based pseudo‑message queue that groups, limits, and batch‑processes game‑level behavior data using Lua scripts, achieving millisecond‑level latency, controlled queue length, and scalable production‑consumer throughput for large‑scale game analytics.
RedisInsight is a powerful GUI for Redis that enables monitoring, CLI interaction, and module support; this guide walks through its features, step‑by‑step installation on physical servers and Kubernetes, environment configuration, service startup, and basic usage including memory analysis and data operations.
This article presents a scalable design for selecting N winners from over ten million users during a flash‑sale event, comparing naive SQL approaches with Redis‑based solutions that guarantee uniqueness, atomicity, and sub‑millisecond latency.
This article explains how Redis evolved from a single‑threaded event‑loop architecture using I/O multiplexing and the Reactor pattern to a multi‑threaded I/O model and an enhanced BIO system with lazyfree, detailing design decisions, source‑code excerpts, performance impacts, and practical lessons for developers.
This article examines the open‑source memory cache Dragonfly, compares its performance and architecture against Redis through detailed benchmark results, discusses Redis’s response and design principles, and provides reproducible test configurations and command lines for both systems.
This article explains how Redis stores key‑value pairs, details the internal data structures such as dict, dictEntry and redisObject, and provides practical memory‑saving tricks—including key shortening, encoding choices, object sharing, bitmap usage, hash consolidation, fragmentation handling, and 32‑bit deployment—to dramatically reduce RAM consumption while maintaining performance.
This article examines Redis 6.0 and 5.0 new features, compares various deployment architectures—including master‑replica, cluster, and read/write‑split—and provides practical guidance, code examples, and performance considerations to help engineers select the optimal Redis setup for production environments.
This article compares the Java Redis clients Jedis, Redisson, and Lettuce, explains their core differences, and provides detailed Spring Boot configuration and code examples for using each client, including RedisTemplate, RedissonClient, and annotation‑based caching.
RedisInsight is a powerful GUI for Redis that offers cluster support, SSL/TLS connections, and memory analysis; this guide walks you through its features, step‑by‑step physical and Kubernetes installations, environment configuration, service startup, and basic usage for monitoring and managing Redis instances.
Redis achieves exceptional speed by operating as an in‑memory database, leveraging compact data structures like SDS, linked lists, hash tables, skip lists and ziplists, running a single‑threaded event loop with I/O multiplexing, and employing optimizations such as lazy‑free, progressive rehashing, and multithreaded network I/O.
This article explains the CAP theorem, details how Redis implements master‑slave replication—including its asynchronous nature, configuration methods, three‑phase workflow, heartbeat mechanism, and common operational issues—providing practical guidance for building highly available Redis deployments.
This article explains how Redis uses its Geo module, combining ordered sets and Geohash encoding, to efficiently implement the “nearby people” feature, covering command usage, detailed source‑code analysis of GEOADD and GEORADIUS, algorithmic steps, and complexity evaluation.
This article provides a comprehensive overview of Redis replication, covering the CAP theorem, master‑slave architecture, configuration methods, authentication, the three replication stages, heartbeat mechanisms, and common pitfalls such as master restarts and backlog size limitations.
This article explains the fundamentals of Redis master‑slave replication, covering CAP theory, the replication workflow, configuration methods, heartbeat mechanisms, and typical problems with practical solutions to ensure high availability and data consistency.
While Kafka dominates large‑scale messaging, this article shows how Redis Streams—an in‑memory, low‑cost alternative—can handle peak‑shaving, buffering, decoupling, redundancy, and robustness, offering simpler commands and higher speed for projects where deploying a full Kafka stack is overkill.
This article outlines Alibaba Cloud Redis development guidelines, covering key naming conventions, value design, command usage, client configuration, lifecycle management, and related tools, with practical examples and code snippets to help avoid common pitfalls and improve performance.
This article explains how to set Redis memory limits, choose appropriate eviction policies such as noeviction, allkeys‑lru, allkeys‑lfu, volatile‑ttl, and describes the underlying LRU and LFU algorithms, including their implementation details and practical configuration commands.
This guide outlines comprehensive best‑practice recommendations for Alibaba Cloud Redis, covering readable key naming, value size limits, safe command usage, client connection pooling, encryption, eviction policies, and efficient big‑key deletion techniques to improve performance and reliability.
The article explains how to build reliable distributed locks using Redis, Zookeeper, and etcd, describing the essential concepts of mutual exclusion, safety, and liveness, showing code examples, highlighting common issues, and comparing each solution's advantages and drawbacks.
An in‑depth comparison shows that while Dragonfly claims to be the world’s fastest memory cache, Redis 7.0 often delivers higher throughput and lower latency across multiple benchmark scenarios, highlighting architectural trade‑offs and the potential for future feature adoption from Dragonfly into Redis.
The article explains how Redis Streams offers a lightweight, memory‑based alternative to Kafka, detailing its features, consumer‑group model, performance advantages, and suitable use cases while acknowledging scenarios where a full‑featured message queue remains preferable.
This article compares the open‑source memory cache Dragonfly, created by a former Google and Amazon engineer, with Redis 7.0, analyzing benchmark results, architectural differences, and community reactions to determine which system delivers superior performance and scalability.
This article traces the development of Redis master‑slave replication from the original SYNC mechanism through PSYNC, PSYNC2, disk‑less replication, shared replication buffers, and the Baidu Cloud PSYNC‑AOF solution, highlighting design challenges, optimizations, and future directions.
This article explains Redis's persistence strategies—including RDB snapshotting with Copy‑On‑Write, AOF command logging with configurable fsync policies, and the hybrid persistence introduced in Redis 4.0—detailing their implementation, performance trade‑offs, configuration options, and practical usage examples.
This article explains Redis's single‑threaded architecture, its limitations, and how Redis 6.0+ adds configurable I/O threads to parallelize read/write handling, detailing the server initialization, event loop, task queues, and the interaction between the main thread and worker threads.
This article explains how to build a precise, persistent delay queue using Redis data structures and Lua scripts, demonstrates a Go client library with code examples for sending, consuming, acknowledging, and retrying delayed messages, and discusses the design requirements such as durability, retry mechanisms, and timing accuracy.
Redis ensures data durability through RDB snapshots and AOF logs—configurable for location, compression, and sync policies—while offering atomic transactions via MULTI/EXEC and simple distributed locks using SETNX (optionally guarded by WATCH) with expirations to prevent deadlocks.
This article explains how to build a reliable delayed message queue using Redis, covering business scenarios, requirements such as persistence and retry, the design of Redis data structures, Lua scripts for atomic operations, and a Go implementation with example code for producing and consuming delayed tasks.
This article explains how to diagnose abnormal memory usage in a Redis 5.0.10 cluster by monitoring memory distribution, comparing instance metrics, checking fragmentation, and using the --bigkeys command to identify oversized keys, providing a practical step‑by‑step troubleshooting workflow.
This article explains why Redis, originally designed as a single‑threaded in‑memory database, introduced a multithreaded network layer in version 6.0, covering the historical design, the limits of CPU vs I/O utilization, the role of I/O multiplexing, and the benefits and drawbacks of the new model.
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.
