This article explores Redis persistence mechanisms, detailing how RDB snapshots and AOF append‑only logs work, how to configure them, their advantages and drawbacks, and guidance on choosing the right strategy for reliable data storage.
RedisConf 2019 highlighted the introduction of multithreaded I/O in Redis 6, detailing its architecture, thread handling of network reads/writes, configuration settings, and benchmark results that show roughly double the throughput for GET/SET commands compared to the single‑threaded Redis 5.0.5.
This article analyzes Redis 6's newly introduced multithreaded I/O feature, explains its design and code implementation, presents benchmark configurations and results that show near‑doubling of GET/SET throughput, and discusses practical considerations and limitations of the approach.
This guide explains how to set up ThinkPHP5's built‑in Queue component with a Redis driver, create a custom queue class, configure the queue, produce messages, and run a consumer process, including handling retries, delays, and daemon mode.
This article explains the two‑layer architecture of NewLife.Redis, demonstrates basic and advanced usage with code examples, shares stress‑test results achieving hundreds of thousands of operations per second, and provides practical tips and FAQs for high‑performance Redis deployments.
This article explores the design and implementation of a Redis‑based distributed lock used since 2013, analyzes lock acquisition and release mechanisms, discusses common pitfalls such as expiration handling and race conditions, and presents possible improvements like Lua scripts and Redisson.
The article examines the risks of using the dangerous FLUSHDB command in Redis, explores common alternatives like SCAN, async deletion, and expiration, and proposes a secondary‑index solution using sets and sorted sets to efficiently invalidate only the affected cache entries without blocking the service.
The article explains how using the KEYS command on millions of Redis keys blocks the single‑threaded server, causing outages, and demonstrates how the incremental SCAN command with cursor, MATCH, and COUNT options provides a safe, non‑blocking way to iterate large keyspaces.
Spring Session enables distributed session sharing by storing HTTP session data in Redis, using a filter and listener configuration to replace Tomcat’s in‑memory storage, managing three Redis keys with coordinated expirations, and subscribing to keyspace events for reliable cleanup and cross‑instance access.
This article lists the comprehensive set of technical and design questions asked in the first, second, and third interview rounds for Alibaba Tmall, covering topics such as JVM garbage collection, concurrency utilities, Redis caching, distributed system design, and performance optimization.
This article explains how to achieve high‑throughput Redis caching with master‑slave replication, cluster scaling, disk‑less sync, incremental replication, and Sentinel‑based automatic failover to reach 99.99% availability and handle tens of millions of QPS.
This article explores Redis beyond its traditional caching role, covering distributed locks, message queues, bitmaps, Bloom filters, geolocation, and rate limiting, while highlighting typical implementation patterns, code examples, and the inherent limitations of each scenario.
This article explains Redis's core data structures—string, hash, list, set, and sorted set—covers why and how data expires, details Redis's periodic and lazy expiration mechanisms, outlines the six memory eviction policies, and provides a Java LinkedHashMap‑based LRU cache implementation.
This article explains how Redis can be scaled for high concurrency using master‑slave architecture, clustering, and read‑write separation, and it details the mechanisms of replication, persistence, Sentinel monitoring, failover, and configuration that together achieve high availability and data safety.
This article explains what Redis is, how it is used for caching in projects, the performance and concurrency advantages of caching, common cache pitfalls, key differences between Redis and Memcached, and the internal single‑threaded event‑driven architecture that enables high‑throughput operations.
This article explains what Redis is, how it is used for caching in projects, the advantages of caching, common cache issues, key differences between Redis and Memcached, and why Redis's single‑threaded design can still support high concurrency.
This article explores cache fundamentals, common pitfalls like penetration and avalanche, naming conventions, warm‑up techniques, and provides step‑by‑step guidance for setting up Redis master‑slave, testing containers, and optimizing configurations for high‑performance backend systems.
This article explains a Java backend architecture with front‑end/back‑end separation, deployment diagrams, the concepts of thread, process and distributed locks, implementations using database optimistic locking, Redis and Zookeeper, session handling in distributed systems, and various related code examples and best‑practice notes.
Redis 5.0 builds on 4.x with new Stream data type, enhanced memory management, and several command improvements—including XADD, XGROUP, XREADGROUP, XACK, and ZPOPMIN/ZPOPMAX—while also adding LFU/LRU support in RDB snapshots and client‑side enhancements for easier cluster management.
This weekly digest summarizes the latest MySQL 8.0.17 enhancements, Redis 6's new RESP3 protocol, free Mycat diagnostics, DBLE and DTLE weekly reports, original technical articles on MySQL fragmentation, dynamic permissions and TempTable engine, plus details of the upcoming Shanghai 3306π meetup.
A high‑severity Redis remote command execution vulnerability (CNVD‑2019‑21763) discovered in July 2019 allows unauthenticated attackers to load malicious modules and execute arbitrary code, affecting Redis 2.x‑5.x, with no official patch yet and only temporary mitigation steps available.
The article explains what cache avalanche and cache penetration are in Redis, why they can crash databases, and provides practical strategies—including random expiration, high‑availability setups, local caches, rate limiting, Bloom filters, and empty‑object caching—to mitigate these issues and maintain cache‑database consistency.
Redis, the in‑memory data store, uses a simple RESP text protocol, offers limited ACID‑style transactions without rollback, employs optimistic locking via WATCH, provides multiple persistence options (RDB, AOF, hybrid), optimizes memory with ziplist and quicklist structures, and implements sophisticated replication and expiration strategies to balance performance and resource usage.
This article explains Redis string basics, its mutable SDS implementation, common commands, internal memory layout, and the three encoding formats (int, embstr, raw) that determine how strings are stored and optimized in the database.
An open‑source maintainer shares candid reflections on the psychological pressure, overwhelming community feedback, role shifts, time constraints, fear of losing technical leadership, friction with contributors, and the sense of futility that accompany the stewardship of a widely used project like Redis.
This article explains why Redis achieves exceptional performance by using pure in‑memory operations, a single‑threaded model, efficient data structures like SDS, skip‑list, ziplist, and various encoding and rehash optimizations that reduce memory allocation and CPU overhead.
This article explains how Redis Cluster distributes data using hash slots and consistent hashing, how nodes communicate via the gossip protocol, and how the Java Jedis client handles redirection and slot migration to achieve scalable, highly available Redis deployments.
This article details a step‑by‑step optimization of a Java search API—covering OpenSearch configuration, batch caching, thread‑pool tuning, and Redis pipelining—that reduced average response time from 150 ms to 32 ms and met a sub‑100 ms SLA.
This article examines how integrating Non‑volatile Memory (NVM) with Redis can replace traditional RDB/AOF persistence, offering a hybrid design that improves durability, reduces recovery time, and maintains high write performance, while discussing implementation details, performance benchmarks, and future optimization challenges.
This article demonstrates how to build a distributed rate‑limiting component named shield‑ratelimiter using Redis’s INCR and TTL features, Spring‑Boot‑starter integration, Lua scripting for atomic operations, custom annotations, and AspectJ, providing a robust, configurable solution for limiting API calls in Java backend services.
The article explains how to use Spark Streaming's mapWithState operator to count product page views, addresses the issue of daily PV reset by presenting two solutions—restarting the streaming job via a scheduled script and configuring a StreamingContext timeout—plus an alternative approach using Redis for external state management.
This article explores how enterprises can effectively use Redis by partitioning clusters for independent or shared use, addressing key naming conflicts, implementing graceful scaling with Zookeeper, monitoring performance via Open-Falcon, and quickly isolating problematic business traffic to maintain system stability.
This article explains why session sharing is required in distributed Java back‑ends, demonstrates how Spring Session automatically synchronizes HttpSession data to Redis, and shows step‑by‑step how to configure Spring Boot, Redis, and Nginx to achieve transparent session sharing across multiple service instances.
This article explains how to use Spring Session together with Redis to achieve transparent HTTP session sharing across multiple Spring Boot instances in a clustered environment, including project setup, Redis configuration, sample controller code, Nginx load‑balancing, and deployment steps.
This guide walks you through installing Docker on CentOS 7.6 and deploying a complete mall stack—including MySQL, Redis, Nginx, RabbitMQ, Elasticsearch, MongoDB, and a SpringBoot service—inside Docker containers, configuring volumes, ports, firewalls, and testing the APIs.
This article explains how to use ThinkJS, a Koa‑based Node.js framework, together with WebSocket and Socket.io to build a multi‑device real‑time chat system, covering protocol basics, server and client configuration, a simple chat demo, and scaling across multiple nodes using Redis.
The article explains how using the KEYS command on large Redis datasets can block the single‑threaded server and cause outages, and demonstrates how the incremental SCAN command safely retrieves keys without impacting performance, including syntax, options, and practical examples.
The article explains how to build a poster‑rendering service with Puppeteer, detailing its advantages over canvas, the Redis‑based caching and CDN workflow, optimization tricks for headless Chromium, and future plans to boost QPS and pre‑generate popular posters.
This article details how a new‑car e‑commerce CRM system was optimized for high availability by introducing ZooKeeper‑based distributed locks, mitigating herd effects, segmenting locks per merchant, and redesigning Redis caching with sorted sets to efficiently rank consultants by daily call volume, resulting in significant performance gains under high concurrency.
This article presents comprehensive Alibaba Cloud Redis development guidelines covering key‑value design, value handling, command usage, client configuration, lifecycle management, related tools, and code examples to help developers avoid common pitfalls and improve performance.
The article explains how the Redis KEYS command can block a production server when scanning millions of keys, analyzes the root cause, and demonstrates how the incremental SCAN command provides a safe, non‑blocking alternative for large datasets.
This article explains how Redis relies on hash tables as the underlying dictionary structure for its databases and data types, detailing the dict layout, collision handling, progressive rehash algorithms, and the safe and unsafe iterator mechanisms used to traverse the hash table.
This guide explains Redis replication in depth, detailing the step‑by‑step slave‑of initiation, the PSYNC command’s role in data synchronization, the full and partial sync processes, heartbeat mechanisms, and asynchronous write propagation, while highlighting key configuration parameters and performance considerations.
This article introduces Redis as an open‑source in‑memory store, outlines its core data structures—strings, hashes, lists, sets, sorted sets, bitmaps, hyperloglogs, and geospatial indexes—and provides concrete command examples, application scenarios, and best‑practice guidelines for effective usage.
This article explains the QR‑code login process, detailing how the web front‑end, server, Redis store, and mobile application cooperate to generate a QR code, verify the scan, and complete user authentication using tokens and UUIDs.
This article walks through Redis from a basic overview to advanced features such as persistence, Sentinel, clustering, data types, transactions, Lua scripting, pipelining, and distributed locks, illustrating each concept with practical examples and explaining when and why to use them in real‑world applications.
This article explains the fundamentals of Single Sign‑On (SSO), compares traditional single‑system login with multi‑system authentication, discusses session and cookie challenges, and provides Java Spring code examples for token‑based SSO using Redis and interceptors.
This tutorial shows how to integrate Spring Security and JWT into a Spring Boot backend to implement user login and authorization, configure Swagger‑UI to automatically include the token, and provides all necessary code snippets, configuration files, and utility classes for a complete authentication solution.
This guide walks you through installing Redis, adding Maven dependencies, configuring Spring Boot, creating a Redis service interface and implementation, and building controller endpoints to generate and verify SMS verification codes, complete with code examples and deployment instructions.
This guide explains how to overcome Redis slowlog retention limits by modifying rsbeat to collect and ship slowlog entries—including sentinel and cluster support—to Elasticsearch, where Kibana can be used for detailed analysis and visualization.
This article compiles practical ELK knowledge, covering character‑set conversion, removing unwanted log lines, Grok pattern handling for multi‑line logs, multiline plugin usage in Filebeat and Logstash, date filtering, log type classification, performance optimization, Redis buffering, and Elasticsearch node tuning.
This article traces the historical laws that drove computing growth, examines how Redis, MongoDB and Memcached evolved, compares client‑side, proxy and compute‑storage‑separated architectures, evaluates their trade‑offs, and answers common questions about cloud‑based distributed databases.
This guide walks through setting up a three‑node ELK stack on Alibaba Cloud, configuring Redis as a broker, installing Filebeat for lightweight log collection, wiring Logstash pipelines, deploying Elasticsearch, Kibana and Grafana, and visualizing Nginx logs with geo‑IP maps and dashboards.
The Mall project is a comprehensive e‑commerce solution featuring a front‑end storefront and back‑office management, implemented with Spring Boot, MyBatis, and a suite of modern technologies such as Redis, Elasticsearch, RabbitMQ, Docker, and more, offering modules for products, orders, marketing, and analytics.
This article walks through a NullPointerException triggered by Spring Data Redis cache, analyzes the root cause in the RedisCache implementation, reproduces the issue with a Spring Boot demo, and provides practical solutions including connection‑pool tuning and custom cache handling.
This guide presents comprehensive best‑practice recommendations for designing Redis keys, choosing appropriate data types, managing key lifecycles, safely using commands, optimizing client connections, handling big keys, and selecting eviction policies to ensure high performance and reliability in production environments.
This article examines Redis's I/O multiplexing mechanism, explaining why it uses non‑blocking models, detailing the Reactor pattern, comparing select, epoll, and kqueue, and providing a thorough walkthrough of the underlying C code that implements event creation, addition, deletion, and polling across platforms.
This article examines various distributed ID generation methods—including UUID, MySQL auto‑increment, Snowflake, and Redis—explaining their advantages, drawbacks, and how top companies combine block allocation and double‑buffering to achieve uniqueness, scalability, and high performance.
This article explains why Redis delivers exceptional performance by examining its pure in‑memory operations, single‑threaded design, efficient data structures such as SDS, dictionaries, skip‑lists, zip‑lists, and the encoding and rehash strategies that keep latency low even under heavy load.
This article explains Redis's memory model—including memory statistics, allocation, object structures, internal encodings, and practical optimization techniques—so developers can accurately estimate memory usage, reduce fragmentation, and improve performance of high‑concurrency applications.
This article introduces distributed locks, explains why they are needed in distributed environments, outlines their characteristics and requirements, and compares three implementation approaches—plain Redis, ZooKeeper, and Redisson—detailing their advantages, drawbacks, and code examples.
This article examines how integrating byte‑addressable non‑volatile memory (NVM) with Redis can resolve the performance‑reliability trade‑off of AOF persistence, delivering near‑always‑mode data safety while maintaining everysec‑like throughput and dramatically reducing recovery time.
This article presents comprehensive Alibaba Cloud Redis development standards covering key and value design, lifecycle management, command usage, client integration, tooling, and efficient big‑key deletion techniques to help developers avoid common pitfalls and improve performance.
This article provides a comprehensive overview of Redis, covering its definition, common use cases, core functionalities, differences from Memcached, single‑threaded design, cache‑penetration mitigation, supported data types, Java clients, consistency strategies, persistence methods, distributed lock implementation, memory optimization, eviction policies, and typical performance issues.
This article provides a detailed analysis of Redis's two persistence mechanisms—RDB snapshots and AOF logging—covering their core concepts, implementation details, trigger conditions, data safety, performance impact, and recovery speed to help engineers choose the appropriate method for their workloads.
This article provides an in‑depth overview of why Redis is used, its drawbacks, the reasons behind its single‑threaded speed, data types and use‑cases, expiration policies, memory eviction strategies, consistency challenges with databases, and practical solutions for cache penetration, cache avalanche, and concurrent key competition.
This article explains why traditional in‑process locks fail under massive concurrency, how distributed locks using Redis or Zookeeper ensure atomic updates across many servers, and details practical implementations, pitfalls like deadlocks, and strategies such as key expiration and ephemeral sequential nodes.
Distributed locks provide mutual exclusion across multiple nodes in scalable, reliable systems, and can be implemented via simple Redis SETNX/EX patterns, ZooKeeper’s EPHEMERAL_SEQUENTIAL znodes with watches, or Redisson’s advanced Java‑centric primitives, each offering distinct trade‑offs in simplicity, consistency, and feature richness.
This article explains Spring's annotation‑based caching, analyzes why the default cache key collides in multi‑tenant scenarios, shows how to embed tenant identifiers into keys, and provides a custom CacheManager implementation that parses TTL from the cache name and applies it to Redis entries.
This article analyzes data‑inconsistency problems caused by concurrent multithreaded updates in a CMDB system and presents a step‑by‑step exploration of synchronization solutions, ultimately implementing a robust Redis‑backed distributed lock in Python to guarantee atomic reads and writes while handling edge cases such as crashes and lock expiration.
The article describes the motivation, analysis, architecture, performance optimizations, development challenges, and future plans of JD Finance’s LEGO backend platform, which uses Spring Boot, SpEL, Redis, and reactive programming to enable dynamic, high‑performance page configuration for a high‑traffic mobile app.
This article explains Redis’s core architecture by detailing its event‑driven model, the initialization of the event loop, how file and time events are handled, and walks through a complete client command flow such as a SET operation, illustrated with key source‑code excerpts.
This article explains Redis's memory model—including memory statistics, allocation, internal data structures like redisObject and SDS, object type encodings, and practical techniques for estimating usage, reducing fragmentation, and optimizing memory consumption—providing developers with actionable insights for high‑performance backend systems.
This tutorial demonstrates how to integrate Apache Flink with Redis as a sink, showing the Maven dependency, a custom RedisMapper implementation, and a complete Flink job that reads Kafka messages, performs word count, and stores results in Redis, with plans for HBase and MySQL extensions.
This article explains how idle TCP connections are silently dropped by Alibaba Cloud security groups, causing Redis client timeouts and MySQL JDBC CommunicationsExceptions, and provides step‑by‑step diagnostics and configuration changes—including TCP keepalive and wait_timeout tweaks—to prevent the failures.
This article explains Redis as an in‑memory data store used for caching, database, and messaging, walks through its evolution from simple HTTP caching to dedicated servers, and details server‑side features like persistence, Sentinel, replication, clustering, as well as client‑side capabilities such as rich data types, transactions, Lua scripting, pipelining, and distributed locks.
This guide presents comprehensive Redis best practices covering key naming, value design, command selection, client configuration, memory‑efficient data structures, and practical Java code for safely deleting large keys, helping developers build high‑performance, reliable Redis deployments.
Facing metadata inconsistency, ten‑thousand‑device scale, and the need for intelligent, event‑driven automation, Tencent Cloud Redis’s sole operations lead built a unified DB‑CMDB, a job‑platform for reusable workflows, and AI‑assisted scheduling, transforming DBAs into developer‑operators and driving 300% efficiency gains.
This article explains how to implement ordinary Redis distributed locks and the advanced Redlock algorithm using Redisson across single‑node, sentinel, and cluster architectures, provides complete Java code examples, and addresses common questions about expiration, high availability, and comparisons with Zookeeper.
This article reviews the evolution of Redis‑based distributed lock implementations—from the simple V1.0 pattern to the more robust V3.1 and Redlock algorithm—highlighting their mechanisms, common pitfalls, and guidance on selecting the most suitable lock for a given scenario.
This article compiles a comprehensive set of interview questions encountered across four technical rounds and an HR session for a major Chinese tech company, covering Java backend architecture, microservices design, RocketMQ, Redis internals, database consistency, networking, algorithms, and practical troubleshooting tips.
This article provides a comprehensive overview of Redis, covering its core concepts, common use cases, and detailed explanations of internal objects such as redisObject, dictEntry, SDS, and the underlying data structures for String, List, Hash, Set, and ZSet, including code snippets and performance characteristics.
This article walks through the evolution of Redis clustering—from early Replication+Sentinel setups, through Proxy‑based solutions, to modern Redis Cluster—detailing their architectures, advantages, drawbacks, and provides practical interview tips and high‑impact answers for candidates.
This article presents thirty practical recommendations for deploying, configuring, and maintaining Pika—a high‑capacity, RocksDB‑backed Redis‑compatible storage system—covering version selection, thread settings, hardware choices, key design, memory management, replication, backup, compaction, security, and monitoring to achieve reliable and high‑performance operation.
Pika 3.0, the open‑source C++ Redis‑compatible storage built on RocksDB, introduces a new Blackwidow engine, enhanced binlog, and optimized server layer, delivering higher interface performance, reduced disk usage, extended key length, full ZSET compatibility, and improved overall efficiency.
This article explains the classic Redis distributed lock using SETNX and Lua, highlights its pitfalls, introduces the advanced Redlock algorithm with step‑by‑step acquisition and release procedures, and provides concrete Java Redisson code examples, illustrating how to implement reliable distributed locks across multiple Redis nodes.
Zhihu built a self‑service analytics platform on Druid, introduced a multi‑level Redis caching strategy, split long‑duration queries across multiple brokers, and added automatic cache invalidation to dramatically improve query latency and resource usage for massive daily request volumes.
This guide reviews Redis’s evolution, highlights key data structures such as bitmap and streams, and provides actionable recommendations on expiration policies, pipelines, namespaces, Lua scripting, configuration tweaks, and monitoring to help developers use Redis efficiently and avoid common pitfalls.
Redis, a high‑performance NoSQL database, offers multiple clustering approaches—including client‑side sharding, proxy‑based solutions like Twemproxy and Codis, and the native Redis Cluster—each with distinct trade‑offs in scalability, availability, operational complexity, and performance, guiding engineers to select the optimal architecture for their workloads.
This article reviews the progression of Redis high‑availability solutions—from simple replication with Sentinel, through proxy‑based setups, to native Redis Cluster—explains their advantages and drawbacks, and provides practical interview Q&A tips for candidates.
This article explains the business background of a flash‑sale (seckill) scenario, analyzes naive locking approaches, introduces Redis‑based distributed locks, and provides a complete Java demo with custom annotations, dynamic proxies, and a multithreaded test to ensure correct inventory decrement under high concurrency.
This article explains Redis’s key features and common use cases, highlights the risks of single‑node deployments, compares two master‑slave replication architectures, and outlines their pros and cons, and details how Redis Sentinel provides automated monitoring, failover, and configuration to achieve high availability.
This article walks through the design of a highly available Redis deployment, explains common failure scenarios, compares single‑node, master‑slave, and multi‑Sentinel architectures, and shows how adding a virtual IP and three Sentinel instances can provide robust HA while keeping client usage simple.
Learn why inventory over‑selling occurs under high concurrency, and explore three practical solutions—pessimistic locking, optimistic locking with version control, and Redis‑Lua scripting—detailing their implementation steps, advantages, and drawbacks to help you choose the best approach for reliable stock management.
This article explains the principles behind TCP's three‑way handshake and four‑way teardown, covering connection establishment, data transfer, termination, header fields, state diagrams, sequence‑number wraparound, SYN‑flood attacks, mitigation techniques, and a practical Redis packet‑capture analysis, all illustrated with diagrams and code snippets.
This article explains the RESP protocol used by Redis, details its five data types, demonstrates pipeline handling with raw sockets, examines the parsing and command‑packing logic of the redis‑py client, analyzes the pipeline implementation and limitations of redis‑py‑cluster, and speculates on upcoming RESP3 features.
The article describes the challenges of handling book outbound operations—matching SN codes, ensuring data consistency, and avoiding lock contention—and outlines a comprehensive refactor that separates business logic, standardizes APIs, adopts asynchronous processing, and leverages Redis sets to achieve high‑performance, reliable SN allocation.
This article details SuNing Financial’s red‑envelope platform architecture and evolution, covering high‑concurrency challenges, traffic shaping, asynchronous processing, multi‑level caching, Redis‑based distributed locks, task scheduling, payment‑chain isolation, high‑availability deployment, multi‑layer flow control, monitoring, and future scalability directions.
This article introduces CIM, a cross‑platform instant messaging framework, detailing its architecture, core components, registration and routing mechanisms, client‑server interaction, custom protocol, built‑in commands, and step‑by‑step deployment using SpringBoot, Netty, Redis and Zookeeper.
This article explains how Redis stores and encodes its five data types by using various in‑memory data structures such as SDS strings, linked lists, quicklists, hash tables, skip‑lists, intsets and zip‑lists, and it also covers object mapping, expiration policies, LRU eviction, and the RDB/AOF persistence mechanisms.
