This article explains why caching is essential for high‑traffic MySQL applications, outlines the consistency challenges of using Redis as a cache, and compares four practical synchronization solutions—TTL‑only, write‑through, message‑queue‑based, and binlog‑driven—highlighting their advantages, drawbacks, and selection guidelines.
This article details the business flow analysis, functional decomposition, database schema, API design, and high‑concurrency implementation of a WeChat red‑packet and seckill system, showcasing Redis atomic decrement, Bloom filter usage, Lua scripts, JMeter load testing, and integration with SpringBoot.
This article explains Redis's asynchronous master‑slave replication, covering the three core mechanisms, partial and full resynchronization processes, configuration methods, diskless sync, key expiration handling, replication IDs and offsets, and safety considerations when disabling persistence.
This article details the end‑to‑end design, database schema, Redis atomic operations, Bloom filter integration, JMeter load testing, and SpringBoot implementation for a high‑concurrency WeChat red‑packet (抢红包) service, including flash‑sale (秒杀) techniques and Lua scripts for atomic stock handling.
This article provides an in‑depth technical overview of Redis, covering its core data structures, memory allocation strategies, eviction policies, persistence mechanisms (RDB and AOF), transaction model, sentinel and cluster architectures, Pub/Sub messaging, and multiple approaches to implementing distributed locks.
This tutorial explains how to implement a Redis distributed lock with SpringBoot and Jedis, covering lock creation using SETNX, expiration handling, safe unlocking via Lua scripts, and a 100,000‑user parallelStream simulation of a limited‑stock order‑grab scenario, complete with code samples and results.
The article shows how a Vue login page can request a SpringBoot endpoint that creates a four‑character captcha image, encodes it as a Base64 data URL, returns it together with a UUID, stores the code in Redis with a two‑minute expiration, and validates the UUID during login.
This article explains how to implement distributed session management, transaction handling, and locking mechanisms in Java applications, covering Tomcat‑Redis integration, Spring Session with Redis, various distributed transaction patterns, and both Redis and Zookeeper based distributed locks with complete code examples.
This article presents a comprehensive design of a flash‑sale system, covering business scenario analysis, high‑concurrency problems such as overselling and malicious requests, and detailed front‑end, Nginx, risk‑control, back‑end, database, and distributed‑transaction solutions to ensure reliability and performance.
This article explains how to use Redis and Redisson for distributed locking, introduces an abstract DistributedLock interface for flexible implementations, demonstrates automatic lock release with functional callbacks, and discusses fallback strategies and monitoring to ensure reliability in backend systems.
This article explains Redis server's event-driven architecture, detailing how file events (read/write) and time events are processed, illustrated with state diagrams, pseudocode, and examples that show the interaction, scheduling, and impact on server performance.
This guide explains how to configure Celery to use Redis as both broker and result backend, covering project layout, code setup, task definition, execution flow, task states, and common control operations for asynchronous Python workloads.
This article explains how Redis implements a single‑threaded architecture by using a file event handler built on non‑blocking I/O multiplexing (select, epoll, evport, kqueue), detailing socket event abstraction, the I/O multiplexing program, event dispatcher, and the mapping of various socket operations to specific handlers.
This article explains the two persistence mechanisms of Redis—RDB snapshots and AOF append‑only logs—detailing how each works, their respective benefits such as backup compactness and durability, and their drawbacks including potential data loss windows and larger file sizes.
This article explains three practical ways to implement distributed locks—using a relational database, Redis cache, and Zookeeper—detailing their underlying mechanisms, Java code examples, performance trade‑offs, and a side‑by‑side comparison of strengths and weaknesses.
This article explains Redis Cluster’s architecture, node and slot management, failover and resharding mechanisms, and how they together affect write safety, detailing commands, metadata storage, conflict resolution, and client redirection strategies in distributed environments.
This article explains the fundamentals of backend architecture, covering Maven's settings.xml, front‑back separation, various types of locks (thread, process, distributed), detailed Redis‑based and Zookeeper‑based distributed lock implementations with code examples, session handling in distributed systems, and key Spring‑Redis caching annotations.
Grafana’s new Redis Data Source plugin lets DevOps engineers and DBAs seamlessly connect to Redis instances—whether open‑source, Enterprise, or Cloud—visualize time‑series and core data types, run management commands, and build interactive dashboards using Grafana’s transformations and built‑in panels.
This article walks through configuring Redisson with Maven, demonstrates a simple distributed lock example using Sentinel, lists the Redis commands and Lua script semantics involved, and provides a detailed source‑code analysis of the RLock interface, tryLock, unlock, and forceUnlock methods.
The article shares the author's recent move to Xi'an, discusses the local job market, and provides detailed interview questions and answers on Java backend topics such as Redis replication, Kafka performance, MySQL transactions, and JVM garbage collection to help job seekers prepare effectively.
This article provides a detailed, step‑by‑step tutorial on building a six‑node Redis cluster on a single Linux machine, covering directory setup, configuration files, Ruby‑based cluster tools, instance startup, cluster creation, verification, online scaling, slot rebalancing, and using Redis for session sharing.
This article provides a comprehensive guide to Redis deployment, covering standalone, master‑slave replication, Sentinel high‑availability, and cluster sharding modes, detailing their principles, advantages, drawbacks, and step‑by‑step configuration examples with Maven dependencies and Redis configuration files.
This article explains why short URLs are used in spam SMS, outlines their benefits, describes the basic principle of mapping long URLs to short ones, and details service design choices such as storage, one‑to‑one mapping, high‑concurrency handling, distributed ID generation, and provides a Java implementation using Redis.
The article details the architecture of 58.com’s SSP advertising platform, identifies three key reliability challenges—data consistency, interface regression, and storage synchronization—and presents a three‑layer testing quality system comprising web‑layer validation, service‑layer automated testing, and data‑layer monitoring with concrete tools and future improvement plans.
This article explains several ways to implement scheduled tasks in Java, covering the simple Timer class, the more robust ScheduledExecutorService, Spring's @Scheduled annotation, and distributed solutions using Redis ZSet and key‑space notifications, with code examples and practical considerations.
This article explains how to configure Redis's maximum memory usage, describes the built‑in eviction strategies such as noeviction, allkeys‑lru, volatile‑lru, random and ttl policies, shows how to query and set these policies via configuration files or runtime commands, and details the LRU and LFU algorithms used by Redis, including Java sample code and recent improvements in Redis 3.0 and 4.0.
This article explains three practical implementations of distributed locks—using a relational database, Redis cache, and Zookeeper—detailing their mechanisms, Java code examples, advantages, disadvantages, and comparative analysis of performance and reliability.
This article explains how to use Spring Integration to implement distributed locks across Redis and Zookeeper, detailing the unified lock API, required dependencies, configuration steps, and sample code for both storage backends.
This page provides a comprehensive list of over 150 Java interview question articles, covering topics such as collections, concurrency, JVM, databases, Redis, Spring, and system design, organized by issue numbers for easy reference.
This article explains the concept of distributed locks, compares system classifications based on safety, and provides detailed implementation guides for Redis‑based locks using SET NX EX, as well as exclusive and shared locks using etcd/Zookeeper with proper handling of TTL, leases, and atomic operations.
This article explores practical database designs for app features like likes, comments, and collections, comparing MySQL partition‑plus‑cache approaches with Redis storage and caching solutions, detailing schema definitions, query examples, Redis commands for various scenarios, and discussing scalability and consistency trade‑offs.
This article explains Redis as an open‑source in‑memory data store used for caching, database, and messaging, walks through its evolution from simple HTTP caching to server‑side Redis, and details core features such as persistence, high availability, clustering, data types, transactions, Lua scripting, pipelining, and distributed locking.
This article introduces Redis Pub/Sub messaging, explains its purpose of decoupling publishers and subscribers, demonstrates command-line operations such as PUBLISH, SUBSCRIBE, PSUBSCRIBE, and provides a complete Java Spring Boot example using Jedis to publish and subscribe to channels.
This article explains the challenges of generating globally unique IDs in sharded databases, compares common solutions such as auto‑increment, UUID, Snowflake, and Redis, and presents a practical MySQL‑based design that uses table‑level auto‑increment combined with in‑memory segment allocation to achieve high concurrency, reliability, and performance.
This article explains how to manage sessions, implement distributed transactions, and coordinate distributed locks in Java-based distributed systems, covering practical solutions with Tomcat‑Redis, Spring Session, CAP theory, XA, TCC, message‑based consistency, Redis locks, RedLock, and Zookeeper locks, complete with configuration and code examples.
The article details how New Oriental's Cloud Classroom backend, built with Java, Spring, MySQL, Redis, Kafka, Sentinel, and other modern technologies, scaled to support millions of users and a hundred‑fold surge in demand during the pandemic through architectural optimizations, distributed caching, traffic control, and rapid performance improvements.
This article dives deep into the design and implementation details of Redis cross‑IDC bidirectional synchronization, covering copy‑loop elimination, conflict handling with Last Write Wins and Vector Clocks, tombstone usage, garbage collection strategies, and the challenges of TTL consistency across replicas.
This article demonstrates how to implement real-time hot item ranking, page view counting, and unique visitor estimation using Apache Flink with Kafka sources, sliding windows, custom aggregation functions, and a Bloom filter backed by Redis, providing complete Scala code examples.
This article outlines the latest upgrades to the open‑source Mall project, including migration to SpringBoot 2.3.0, support for Elasticsearch 7.6.2, enhanced ELK log collection, unified Swagger and Redis configurations, and updated deployment guides for Windows and Linux environments.
This article analyzes a real‑world flash‑sale overselling 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 and atomic stock decrement strategies to prevent future overselling.
This article explains how to implement automatic idempotency for Spring Boot APIs using Redis, a custom @AutoIdempotent annotation, token generation and validation, and an interceptor, providing step‑by‑step code examples, configuration details, and testing procedures to ensure each request is processed only once.
This guide demonstrates how to integrate Apache Shiro into a Spring Boot application, covering project setup, Maven dependencies, configuration of Redis-backed session and cache management, creation of utility and realm classes, and implementation of role‑based permission controls with example controllers and Postman testing.
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.
