This article recounts a developer's step‑by‑step optimization of a search API—detailing four load‑test rounds, configuration tweaks, batch queries, caching, and code clean‑up—that ultimately reduced average response time from 150 ms to 32 ms, meeting a sub‑100 ms requirement.
This article analyzes a real‑world overselling incident caused by an unsafe Redis distributed lock in a high‑traffic flash‑sale service, explains the root causes, and presents safer lock implementations, atomic stock checks, and architectural improvements to prevent similar failures.
This article analyzes a real over‑selling incident caused by unsafe Redis distributed locks, explains the root causes such as lock expiration and non‑atomic stock checks, and presents safer lock implementations, atomic stock updates, and architectural improvements to prevent future failures.
This article describes how Ctrip's ticket order post‑service team identified scaling bottlenecks, selected Redis, designed a two‑level cache architecture, implemented active and passive caching strategies, tackled consistency and failure issues, and applied various optimizations to achieve over 90% cache hit rate and dramatically reduce database load.
This article explains Redis Cluster’s automatic sharding, built‑in high availability, the role of the cluster bus ports, the limitations of traditional hash algorithms, and how consistent hashing with virtual nodes and the 16384‑slot hash slot mechanism enable efficient data distribution and low‑cost node scaling.
This article explains why simple SETNX/EXPIRE commands can cause deadlocks, shows how to achieve atomic lock operations with Lua scripts or the Redis SET command, and demonstrates how to use the Redisson library for re‑entrant, auto‑renewing distributed locks in Java.
Redis Sentinel is a crucial component of Redis clustering that monitors master and slave instances, sends alerts, performs automatic failover, and updates clients with new master addresses, while operating as a distributed system requiring a quorum of nodes to ensure robust high‑availability.
This article explains Redis 6.0’s built‑in client‑side caching, demonstrates how to install Redis via Docker, configure Lettuce snapshot dependencies, write Java code to enable and test cache synchronization, monitor Redis commands, and outlines current limitations of Lettuce and Spring Boot support.
This article explores the requirements and database design patterns for implementing likes, comments, and favorites in apps, comparing traditional MySQL schemas with Redis‑based storage and caching solutions, and discusses their trade‑offs, scalability, and data consistency considerations.
Facing a ten‑fold cost increase for public‑cloud Redis, Ctrip engineers evaluated Redis‑on‑SSD alternatives, chose KVROCKS, performed extensive protocol‑compatible modifications, benchmarked performance on standard and Optane SSDs, and demonstrated substantial cost savings while preserving Redis semantics.
Redis ensures high availability through two persistence mechanisms—RDB snapshots and AOF logs—each with distinct advantages, trade‑offs, and configuration nuances, and this guide explains how they work, when to choose each, and how they impact performance and data safety.
Redis, an in‑memory key‑value store, lets you set a maximum memory limit via configuration files or runtime commands, choose among various eviction strategies such as noeviction, allkeys‑lru, volatile‑lru, and LFU, and understand how approximate LRU works, with Java code examples illustrating these concepts.
This article explores Redis 6.0’s new client‑side caching feature, detailing the tracking command, its options such as BCAST, PREFIX, OPTIN, OPTOUT, REDIRECT and NOLOOP, and provides step‑by‑step examples using telnet and redis‑cli to demonstrate invalidation messages and configuration.
This article explains why Redis needs high availability, defines common failure scenarios, compares several HA solutions, and walks through four deployment patterns—culminating in a three‑Sentinel architecture with a virtual IP to provide seamless, fault‑tolerant Redis access.
This article provides a comprehensive overview of using Lua scripts with Redis, covering Lua basics, advantages of Lua scripting, detailed Redis‑Lua integration syntax, command usage, return‑type mappings, script management commands, and step‑by‑step instructions for installing Lua and executing example scripts.
This article explains Redis's custom Simple Dynamic String (SDS) implementation, its dynamic expansion mechanism, and the performance benefits such as O(1) length retrieval, buffer overflow avoidance, and efficient memory allocation strategies for high‑throughput applications.
This guide demonstrates how to integrate the lightweight Apache Shiro security framework into a Spring Boot application, covering environment setup, Maven dependencies, Redis-backed session and cache configuration, utility classes, core Shiro components, annotation‑based permission control, and Postman testing for token handling and dynamic permission updates.
This article explains how to configure Redis's maximum memory usage, modify memory limits at runtime, understand the built‑in eviction strategies—including noeviction, allkeys‑lru, volatile‑lru, allkeys‑random, volatile‑random, and volatile‑ttl—how to query and set these policies, and the details of LRU and LFU algorithms with Java examples and performance comparisons.
This article details Ctrip's practical design and implementation of a bidirectional Redis synchronization system across data centers, covering replication loop breaking, conflict resolution with Last Write Wins and Vector Clocks, tombstone handling, garbage collection strategies, and expiration policies to ensure data consistency.
This article explains Redis 6.0’s new client‑side caching feature, detailing the tracking command, its options such as BCAST, PREFIX, OPTIN, OPTOUT, NOLOOP and REDIRECT, and provides step‑by‑step examples using telnet and redis‑cli to demonstrate how invalidation messages are generated and handled.
This article analyses the limitations of existing global unique ID solutions such as Snowflake, presents the design of a new high‑performance, time‑independent Mist algorithm with extended lifespan, and describes its practical Redis‑backed service Medis, including performance benchmarks and architectural considerations.
This article provides a comprehensive overview of Redis, covering its definition, advantages over memcached, supported data types, memory consumption, eviction policies, clustering options, persistence mechanisms, distributed lock implementations, cache penetration and avalanche solutions, and best-use scenarios compared to other caching systems.
This article explains how Redis handles key expiration, detailing which commands clear or keep TTL, how PERSIST and RENAME affect expiration, the impact of negative or past timestamps, and the lazy and periodic deletion strategies Redis uses to manage expired keys efficiently.
This article explains the concept of distributed locks, compares various implementation approaches such as Memcached, Zookeeper, Chubby, and Redis, and details single‑node and multi‑node Redis lock designs—including SETNX, SET with NX/EX options, Redisson, and the Redlock algorithm—while highlighting their advantages, pitfalls, and best‑practice recommendations.
This article explains the fundamentals and pitfalls of using Redis for distributed locking, covering the setnx command, the SET command with NX and PX options, Lua‑based lock scripts, Redisson’s lock implementations, and the RedLock algorithm, along with practical code examples.
During a technical interview, the candidate explains various distributed ID generation methods—including database auto‑increment, sharding, batch allocation, UUID, Redis atomic counters, and the Snowflake algorithm—analyzes their pros and cons, and provides Java code examples for Redis‑based and Snowflake ID generators.
This article explains the database design for likes, comments, and favorites in apps, comparing MySQL table structures and Redis storage solutions, discussing query patterns, scalability challenges, and data consistency measures for moderate to massive traffic scenarios.
This article explains why cache penetration and cache breakdown occur in high‑traffic systems and presents practical solutions such as null caching, Bloom filters, mutex locks, and asynchronous cache rebuilding, while discussing their advantages, limitations, and appropriate usage scenarios.
The article introduces kk-anti-reptile, a Spring Boot‑based anti‑crawler component that uses servlet filters, Redis, and configurable rule chains (IP and User‑Agent), explains its workflow, shows Maven and property configurations, and provides front‑end Axios interception code for handling 509 responses.
This article explains Redis transactions in depth, covering their command workflow, the MULTI/EXEC/DISCARD/WATCH/UNWATCH commands, error handling, practical code demonstrations, and a comparison with MySQL transaction semantics to help readers master Redis transaction usage for interviews and development.
This guide shows how to configure a Redis exporter alongside a Redis pod in Kubernetes, add Prometheus scrape annotations, apply the deployment and service manifests, and visualize metrics in Grafana, providing step‑by‑step commands, YAML examples, and screenshots of the monitoring dashboard.
Redisson version 3.13.2, a Java‑based Redis client with in‑memory data grid capabilities officially recommended by Redis, has been released, introducing sharding support via ShardedRedisson, new CLUSTERDOWN error handling, added configuration methods to RedisNode, and numerous bug fixes covering sentinel handling, cache clearing, SSL reconnection, and more.
This article presents a complete case study of diagnosing and optimizing a high‑traffic flash‑sale module in a Java SSM monolithic e‑commerce system, covering problem identification, root‑cause analysis, JVM/Tomcat/Redis/JDBC tuning, code refactoring, and the resulting stability improvements.
This article explains the fundamentals of Redis locking mechanisms, including the setnx command, the RedLock algorithm, and how the Redisson Java client implements distributed locks with Lua scripts, highlighting pitfalls, best practices, and code examples for safe lock acquisition and release.
The article recounts Redis creator Salvatore Sanfilippo’s decision to step back from core development, explains his fatigue with open‑source maintenance, outlines the pressures he faced, and discusses how mature projects like Redis can continue thriving after a founder’s departure.
This tutorial walks you through compiling Redis from source, configuring six cluster nodes on ports 7000‑7005, adjusting system memory settings, creating startup scripts, launching the services, forming the cluster, verifying its status, and testing basic read/write operations, all with detailed command examples.
The article recounts Salvatore Sanfilippo’s decision to relinquish his role as Redis’s benevolent dictator, outlines the new community‑driven governance model led by Yossi Gottlieb and Oran Agra, and reflects on his personal philosophy about code as artistic self‑expression while highlighting Redis’s continued prominence as a leading NoSQL database.
The article introduces the JdHotkey framework, a lightweight, real‑time hotkey detection solution for Redis and other services, detailing the risks of hot keys, prior mitigation methods, core design components, operational workflow, and performance benchmarks across various hardware configurations.
This article explains how Redis handles memory limits with the maxmemory setting, describes the six eviction policies—including noeviction, allkeys‑lru, volatile‑lru, allkeys‑random, volatile‑random, and volatile‑ttl—covers the LRU and LFU algorithms, and outlines the three key expiration deletion methods as well as RDB and AOF persistence handling.
RedisDesktopManager 2020.1 introduces enhanced Pickle formatting for NumPy and pandas objects, adds the ability to save values to files, and fixes several bugs including dark‑mode and formatter issues, while continuing to support fast, cross‑platform Redis management via SSH tunnels.
This guide walks you through creating Zabbix auto‑discovery scripts to extract all Redis INFO parameters, configuring custom keys, setting permissions, and building a complete Redis monitoring template with step‑by‑step screenshots.
This comprehensive guide explores Redis fundamentals, detailing its six primary data structures—strings, lists, hashes, sets, sorted sets, and streams—along with practical command examples, internal implementations, and usage patterns for high‑performance backend development.
This article explains how Xiaomi migrated tens of thousands of Redis instances from bare‑metal servers to Kubernetes, using Redis Proxy, StatefulSets, and Ceph storage to achieve resource isolation, automated deployment, dynamic scaling, and improved reliability while addressing latency, IP‑change, and security challenges.
This article explains the concept of reentrant distributed locks and provides two Java implementations—one using ThreadLocal for local counting and another using Redis Hash with Lua scripts—detailing the code, pitfalls, and integration with Spring Boot.
This article explains the purpose of flow control, compares various rate‑limiting algorithms—including simple window, sliding window, leaky bucket, token bucket, and sliding log—provides Java interface definitions and code examples, discusses their complexity, precision, smoothness, and suitability for single‑machine and distributed scenarios, and offers practical deployment tips using Sentinel, Nginx, Guava, Tair, and Redis.
This article explains how to design a secure token mechanism with timestamp validation, describes common DoS attack types, and provides practical Spring Boot code examples—including Redis configuration, token generation, interceptor logic, MD5 signing utilities, and ThreadLocal usage—to prevent repeat submissions and protect APIs.
This article details the 2015 hybrid data‑warehouse design implemented at Guangdong Huaxing Bank, explaining its real‑time, historical, and archival layers, the data‑bus concept, and how mixing in‑memory, relational, and Hadoop technologies addressed modern banking data‑volume, latency, and unstructured‑data challenges.
This article analyzes a financial system's duplicate income‑splitting bug caused by concurrent transactions, explains how MySQL isolation levels and Spring transaction propagation contributed to dirty reads, and presents two corrective approaches—adjusting transaction propagation and repositioning Redis locks—to ensure reliable data consistency.
This article explains why redoing a system can be simpler than refactoring, then dives into implementing a reentrant distributed lock using Redis with both ThreadLocal and Redis Hash approaches, providing detailed Java code, Lua scripts, and practical tips for handling lock expiration and multi‑process reentrancy.
This article outlines comprehensive development guidelines for Alibaba Cloud Redis, covering readable and concise key naming, avoiding big keys, proper command selection, safe client usage with connection pools, eviction policies, and practical code examples for deleting large hashes, lists, sets, and sorted sets.
This article presents a concise Redisson distributed‑lock example with Maven configuration, demonstrates basic lock usage, enumerates the Redis commands and Lua script semantics involved, and provides a detailed walkthrough of the relevant Java source code, highlighting key implementation details.
This article explains why traditional locks fail in high‑concurrency scenarios like large‑scale red‑packet distribution, and demonstrates how distributed locking mechanisms using Redis and Zookeeper ensure correct total amounts while avoiding deadlocks and thundering‑herd problems.
This article provides a comprehensive, step‑by‑step tutorial on creating a Redis Cluster using Docker, covering the preparation of a base Redis image, building node images, configuring cluster settings, assigning hash slots, adding replica nodes for high availability, testing failover, and solving network connectivity issues for production deployments.
This article explains how Redis can be used for distributed locking, covering the setnx command, the SET command with NX and PX options, common pitfalls, Lua‑based atomic unlock scripts, the Redisson client, and the RedLock algorithm for achieving reliable locks across multiple nodes.
This article explores Redis locking mechanisms, explaining the SETNX command, its limitations, the use of PX for timeouts, Lua scripts for atomic unlocks, and introduces Redisson’s advanced lock implementations including RedLock, while highlighting practical pitfalls and best‑practice recommendations for reliable distributed synchronization.
This tutorial walks through preparing three CentOS 7 servers, installing and compiling Redis 6.0.3, configuring master‑slave replication, setting up Sentinel for high availability, adjusting firewall and Redis configuration, and managing the services to achieve a fully functional Redis cluster.
This guide walks through installing Supervisor on CentOS 7, configuring its core settings, creating program definitions for Tomcat and Redis, and managing services with supervisord and supervisorctl, providing a reliable solution for automatic process recovery on Linux/Unix systems.
This article outlines comprehensive development guidelines for Alibaba Cloud Redis, covering key naming conventions, value design, command best practices, client usage patterns, related tools, and detailed code examples for safely deleting large keys across various data structures.
This article examines the functional requirements for likes, comments, and favorites in apps and compares MySQL and Redis based database designs, discussing schemas, queries, scalability challenges, and consistency considerations for handling moderate to massive data volumes.
This article explains how loop‑based database queries degrade performance and demonstrates three concrete optimizations—using IN clauses in MySQL, aggregation pipelines in MongoDB, and Redis pipelines—to replace repetitive queries with bulk operations, improving speed and maintainability.
This guide walks you through installing Supervisor on CentOS 7.6, configuring its core settings, creating process definitions for Tomcat and Redis, and using supervisorctl and systemd to start, stop, and monitor these services, ensuring automatic recovery on failure.
This page compiles a chronological list of 100 WeChat articles covering Java interview topics, including core language concepts, data structures, concurrency, Spring, MySQL, Redis, and system design, providing readers with direct links to each issue for comprehensive preparation.
This article compares Memcached and Redis, covering their installation, shared features such as sub‑millisecond latency and language support, and key differences in data structures, persistence, replication, transactions, pub/sub, geospatial commands, scripting, and memory efficiency to help you choose the right cache solution.
This article recounts how Salvatore Sanfilippo, despite a decade of experience in traditional relational databases, abandoned conventional design principles to create Redis, an open‑source in‑memory NoSQL system that now powers major services worldwide.
This article explains how to extend Redis beyond single‑node limits by using partitioning, master‑slave replication, Sentinel for automatic failover, and Redis Cluster with hash slots, detailing their usage, advantages, drawbacks, and configuration examples for building high‑availability and scalable in‑memory data stores.
This article provides an in‑depth guide to Redis, covering its core data types, internal data structures, common usage scenarios, differences from Memcached, key expiration, eviction policies, persistence mechanisms, transactions, event handling, replication, Sentinel, sharding, and a practical forum system example.
Redis is a high‑performance, open‑source key‑value store offering persistence, rich data structures, replication, pub/sub, transactions, and clustering; this guide explains its fundamentals, data types (string, hash, list, set, sorted set), essential commands, and advanced features such as persistence options, replication, Sentinel, and sharding.
This article reviews common unique identifier generation techniques—including database auto‑increment, UUID, Redis counters, Snowflake, Zookeeper, and MongoDB ObjectId—detailing their advantages, drawbacks, and practical implementation examples with C# code snippets.
This guide explores Redis key expiration policies—including active, lazy, and periodic expiration—memory eviction strategies, resource consumption, thread model, and transaction mechanisms, providing practical insights on configuring TTL, optimizing memory usage, and understanding Redis’s single‑threaded architecture for reliable data handling.
This comprehensive guide explains Redis’s architecture, performance advantages, data types, common use cases, persistence options, and scaling strategies, helping developers decide when and how to leverage this high‑speed in‑memory database for caching, session management, and more.
This article explains the complete technical workflow of QR‑code login, covering the generation of UUIDs, Redis storage, browser polling, mobile‑side verification, token handling, and detailed implementations in Taobao and WeChat, while also providing code snippets and diagrams for reference.
This article demonstrates how to integrate Redisson with Spring Boot to create Redis‑based distributed locks, covering Maven dependencies, YAML configuration, a Redisson configuration class, utility methods for locking and unlocking, and a sample controller that simulates concurrent access to verify lock behavior.
This article explains how to configure Redis's maximum memory usage, describes the various eviction strategies such as noeviction, allkeys‑lru, volatile‑lru, and introduces both LRU and LFU algorithms with Java examples and practical configuration commands.
This article analyzes why Redis service nodes may experience massive TimeoutException errors, covering external influences such as CPU and memory contention, network resource exhaustion, and internal Redis usage issues like slow queries, persistence overhead, and configuration pitfalls, and provides concrete diagnostic commands and mitigation steps.
This article explains how Redis uses memory, covering memory fragmentation analysis, object and buffer memory consumption, sub‑process memory overhead, and practical configuration of maxmemory limits and eviction policies to optimize performance and prevent out‑of‑memory failures.
This article explains the concepts, advantages, and drawbacks of MySQL pessimistic and optimistic locks, shows how to implement each with SQL and PHP code, compares their suitability for different traffic patterns, and demonstrates a Redis‑based optimistic lock for high‑concurrency flash‑sale scenarios.
This article explains how to configure Redis's maximum memory usage, describes the various eviction strategies including noeviction, allkeys‑lru, volatile‑lru, random and ttl policies, shows how to query and set these policies via configuration files or commands, and provides Java code for a simple LRU cache while discussing Redis's approximate LRU and LFU algorithms.
Static business data in microservice systems, such as vehicle models and user profiles, change rarely yet demand high accuracy and real‑time access; this article proposes a universal caching architecture using a business service, persistent queue, Redis cache, and consistency checks to achieve scalable, reliable reads.
This tutorial walks through compiling the php‑redis extension, installing Laravel, configuring Redis as a cache and database driver, setting up a Redis cluster, and provides sample PHP code for read/write operations, offering a comprehensive guide for backend developers.
This article details the background, initial ECS‑based deployment, performance bottlenecks during rapid user growth, and the comprehensive cloud‑native migration—including DNS load balancing, managed Kubernetes, CDN acceleration, RDS/Redis replacement, and NAS/OSS storage—resulting in significant scalability and operational improvements for the Smart Citizen Pass mini‑program.
This guide walks through preparing three CentOS 7 servers, installing Redis 6.0.3, configuring master‑slave replication, handling common compilation errors, setting up system startup, adjusting firewall and Redis settings, and finally enabling Sentinel for high‑availability monitoring.
The article explains Reddit's large‑scale page‑view counting system, detailing its real‑time requirements, the challenges of naive hash‑set storage, and how a hybrid approach using linear probability and HyperLogLog algorithms together with Kafka, Redis, and Cassandra achieves accurate, low‑memory, near‑real‑time analytics.
This article explains the end‑to‑end implementation of QR‑code login, covering how a web page requests a QR image, how the server stores a UUID in Redis, how a mobile app scans the code and validates the user, and how the browser finally receives a token to complete authentication.
During a full‑chain load test, latency spikes were traced to a slow G1GC pause caused by single‑threaded reference processing of many Finalizer objects, which originated from an over‑aggressive Jedis connection pool; enabling the JVM flag -XX:+ParallelRefProcEnabled eliminated the bottleneck and restored performance.
This article explains how a large car‑IoT platform built a comprehensive Redis monitoring solution using Elastic‑Stack, covering server‑side metrics, application‑side instrumentation, joint analysis, implementation details, findings, and future optimization recommendations.
This article explores multiple backend strategies for implementing a location‑based “nearby users” service, covering pure MySQL queries, MySQL combined with GeoHash, Redis Geo commands, and MongoDB geospatial indexes, explaining design principles, pros and cons, and providing complete code examples for each approach.
This article explains the QR code login process, detailing how a web page requests a QR code, how the mobile app scans it, exchanges tokens via Redis, and ultimately authenticates the user across web and mobile platforms.
This article details CTrip's evolution of Redis management—from early single‑instance deployments and custom CRedis client, through automated scaling, containerization with Kubernetes, secondary scheduling algorithms, Intel Optane integration, and hybrid‑cloud deployment—highlighting operational challenges, solutions, and performance outcomes.
This article provides a comprehensive tutorial on Redis Cluster, covering its architecture, data partitioning and redundancy, step‑by‑step instructions for downloading, compiling, and installing Redis on CentOS, as well as detailed procedures for manually or automatically creating a six‑node cluster with master‑slave replication and slot allocation.
This article explains Redis's two persistence mechanisms—RDB snapshot files and AOF append‑only logs—including their operation, configuration commands, advantages, disadvantages, recovery procedures, and performance recommendations for choosing between them.
Redis 6.0.0 GA, the biggest release to date, adds a redesigned client cache, ACL improvements, faster RDB loading, a new STRALGO command, and optional multithreaded I/O that can double network performance, while urging careful testing before production use.
The author reflects on recent campus recruitment interviews, sharing personal anecdotes, common pitfalls in Java fundamentals, collections, concurrency, and Redis, and offers practical advice on how candidates can improve their technical depth and interview performance.
This comprehensive guide explains what Redis is, its advantages and drawbacks, why it excels as a high‑performance cache, the supported data structures, persistence mechanisms, memory eviction policies, threading model, transaction handling, clustering and sharding options, distributed locking, common cache pitfalls, and useful tooling for Java developers.
Redis 6.0.0 stable release brings major updates such as redesigned client‑side caching, immediate RDB deletion for replication, enhanced ACL logging, faster PSYNC2 partial resynchronization, decimal timeout support, up to 30% faster RDB loading, and a new STRALGO command for string algorithms.
This article explores various strategies for controlling execution timing in Java backend services, comparing Thread.sleep, Timer, and Redis-based expiration techniques, and provides practical code examples and configuration steps for integrating Redis with Spring Boot to achieve reliable delayed processing.
This article explains the technical principles and step‑by‑step implementation of QR code login used by major platforms like WeChat and Taobao, covering server‑side UUID generation, Redis storage, token exchange, client polling, JSONP handling, and concrete code examples.
This guide presents ten practical Redis best‑practice tips—including avoiding KEYS *, using SCAN, analyzing command stats, leveraging hashes, setting expirations, choosing eviction policies, handling errors, scaling with clusters, understanding threading limits, and configuring Sentinel for high availability—to help you run Redis efficiently and safely.
This article explains Ctrip's high‑availability designs for SQL Server, MySQL, and Redis, describing multi‑replica strategies, evolution from legacy mirroring to AlwaysOn, multi‑node MHA management, and Redis sentinel‑based failover, while emphasizing fault‑tolerance across data centers.
This article introduces Redis as an open‑source in‑memory data‑structure store, explains its role as a NoSQL database, covers fundamental data types, common commands, expiration handling, and advanced features like pipelines and transactions, providing a comprehensive guide for developers.
This article explains what Redis Cluster is, how it partitions data and provides redundancy, and walks through installing Redis on CentOS, configuring multiple nodes, and creating a functional cluster using both manual commands and the built‑in cluster management tool.
