This article explains how Redis Cluster uses hash slots for data partitioning, enables near‑linear scaling and fault‑tolerant failover through master‑slave replication, and requires client‑side routing support, while discussing the trade‑off between performance and consistency in distributed systems.
The article categorizes data by change and access frequency, explains cache loading methods, compares local caches (Map, Guava, Spring) with remote solutions like Redis, Memcached, Hazelcast, and addresses common cache issues such as penetration, breakdown, and avalanche, offering practical mitigation techniques including Bloom filters, RoaringBitmap, and load‑balancing strategies.
Geohash encodes latitude‑longitude pairs into short base‑32 strings by recursively bisecting coordinate ranges and interleaving bits, allowing fast proximity queries via prefix matching, with precision controlled by string length, and is supported natively in Redis and useful for location‑based services.
This article walks through creating a reusable Redis connection‑pool manager and a functional wrapper class in Java, explaining pooling concepts, resource recycling, and providing ready‑to‑use methods for common Redis commands to support efficient performance testing with the FunTester framework.
This article compares MySQL‑based single and multi‑record stock deduction methods with a Redis‑based approach that uses Lua scripting and distributed locks, providing full Java implementation details and REST examples for high‑concurrency inventory management.
This article compares delayed and scheduled tasks, explains their differences, and presents five practical Java implementations—including Quartz polling, JDK DelayQueue, Netty's HashedWheelTimer, Redis ZSET, and Redis keyspace notifications—along with their advantages, drawbacks, and sample code.
This article compares delayed and scheduled tasks, explores five implementation strategies—including database polling, JDK DelayQueue, time‑wheel algorithm, Redis sorted sets, and RabbitMQ—provides code samples, analyzes pros and cons, and offers practical guidance for building reliable delayed‑task systems.
This article explains how to identify oversized Redis keys, analyze their impact with built‑in commands and third‑party tools, and safely remove them using UNLINK and lazy‑free configurations to prevent performance bottlenecks.
This article explains the design and step‑by‑step implementation of a Redis delay queue using Java and Spring, covering the workflow, core components, task states, public APIs, container classes, timer handling, and testing procedures with complete code examples.
This article explains the concept of idempotency, the common causes of duplicate submissions in web applications, and presents multiple backend solutions—including frontend button disabling, Post‑Redirect‑Get, session tokens, local locks with Content‑MD5, AOP aspects, and Redis distributed locks—accompanied by complete Java code examples.
Redis, the high‑performance open‑source key‑value store, uses a master‑slave replication mechanism that ensures data redundancy, read/write separation, fault recovery, and high‑availability; this article explains its handshake process, synchronization phases, replication states, and key source‑code functions in detail.
This article presents a PHP implementation of Redis-based rate limiting, explaining how to limit the number of requests per time interval by using timestamp-modulo keys, atomic increment operations, and key expiration, along with detailed code and step-by-step commentary.
This article explains how to implement efficient real-time WebSocket message pushing in a distributed system by using Redis as a coordination layer, defining Go-based Client and ClientManager components, and detailing the end‑to‑end flow from message production to client delivery.
This article explains the core concepts and detailed design of a custom message queue built on a distributed key‑value store, covering terminology, architecture, broker metadata, topic metadata, message format, sending, storage, retrieval, delay handling, retry mechanisms, dead‑letter queues, and TTL policies.
This article compares several Java-based delayed‑task solutions—including database polling with Quartz, JDK DelayQueue, Netty’s HashedWheelTimer, Redis sorted‑set or key‑space notifications, and RabbitMQ delayed queues—detailing their implementations, advantages, drawbacks, and practical code examples for reliable order‑timeout handling.
This article explains Redis Sentinel's role in providing high availability by detailing how Sentinels discover each other, detect master failures, elect a new master, and communicate state using the gossip protocol, offering a clear conceptual overview for database practitioners.
This article examines the characteristics of Redis and Memcached as distributed cache solutions, outlines common design pitfalls such as consistency, cache penetration, breakdown, avalanche, and hot‑key issues, and provides practical strategies—including consistent hashing, binlog‑driven invalidation, message‑queue indexing, and lock mechanisms—to build reliable and high‑performance caching layers in backend systems.
This article explains Redis's fundamental and advanced data structures, outlines its single‑threaded in‑memory architecture, and provides practical guidance on scanning large keyspaces, spreading expiration times, and choosing between AOF and RDB persistence methods.
This article explains Redis's virtual memory (VM) feature, how it swaps cold data to disk while keeping keys in memory, details configuration parameters, describes the two threading models for data swap-in/out, and highlights why Redis's custom VM implementation boosts performance.
Redis latency spikes can stem from complex commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, or network saturation, and this guide explains how to identify, monitor, and mitigate each cause using slowlog, bigkeys, info, and configuration tweaks.
This article reviews Redis's latest features and compares various deployment architectures—including single‑replica, dual‑replica, cluster, and read‑write‑separation modes—detailing their reliability, performance characteristics, suitable use cases, and provides a Java Jedis example for configuring a direct‑connect cluster.
This guide explains what Redis Sentinel is, its architecture, how to configure it in a master‑slave environment, and demonstrates handling slave and master failures as well as setting up multiple Sentinel instances for robust high‑availability Redis clusters.
This article examines the landscape of cache systems, compares four major categories, evaluates popular distributed caches such as Redis, Memcached, Tair and EvCache, explains Redis Cluster architectures and sharding strategies, and outlines common cache pitfalls with practical mitigation techniques.
This article provides a comprehensive overview of caching in large distributed systems, covering theory, common components, classification, CDN and reverse‑proxy caches, local application caches, popular implementations like Ehcache, Guava, Memcached and Redis, and a detailed comparison of their features and trade‑offs.
This article walks through the evolution of Redis‑based distributed locks, illustrating common pitfalls and step‑by‑step improvements—from simple set‑if‑absent locks to atomic UUID checks and Lua‑scripted releases, culminating in a robust Redisson solution.
This article explains why Redis, despite being single‑threaded, can encounter thread‑safety problems, discusses efficiency bottlenecks caused by network latency, and shows how embedded Lua scripts can create custom atomic commands, with practical examples and important considerations.
In a Redis cluster, bulk MGET calls suffered intermittent latency spikes because keys were distributed across many hash slots, forcing multiple network round‑trips; the issue can be mitigated by grouping keys with a common hash tag (though it reduces HA) or by issuing parallel slot‑wise MGETs with careful tuning, which preserves topology for larger batches.
This guide walks through creating a Spring Boot 2.2.11 OAuth2 authorization server that stores tokens in Redis, defines custom client and user entities, configures grant types, and demonstrates testing each flow, complete with code snippets and configuration files.
Redis, traditionally seen as a high‑performance cache, also offers rich data structures, persistence options, and clustering modes that enable it to function as a primary database for many internet services, supporting use cases such as user profiles, counters, leaderboards, friend relationships, distributed locks, rate limiting, and more.
The article explains Redis 6.0's new features—especially the multithreaded network I/O model—why earlier versions were single‑threaded, how the IO threads cooperate with the main thread, configuration steps, thread‑count recommendations, and the model's limitations and performance implications.
This article explains the concept, essential characteristics, and common generation strategies—including database auto‑increment, UUID, Redis, Zookeeper, and Twitter's Snowflake—highlighting their advantages, drawbacks, and practical optimization tips for building reliable distributed systems.
This article outlines the new features of Redis 6.0 and 5.0, compares various deployment architectures such as master‑replica, single‑replica, cluster and read‑write split, presents typical usage scenarios, and provides a Java Jedis code sample for connecting to a Redis cluster.
This article explains why Redis can encounter thread‑safety‑like problems, how network latency limits its performance, and how embedding Lua scripts lets you create atomic, server‑side commands that overcome these issues while providing practical code examples.
This article explains the various types of auto‑increment identifiers in MySQL—including table primary keys, InnoDB row_id, Xid, trx_id, thread_id—and discusses their maximum values, overflow behavior, and alternative solutions such as using Redis for external unique keys.
This article examines the consistency challenges of using Redis as a cache, compares three update strategies—updating the database before the cache, deleting the cache before updating the database, and updating the database then deleting the cache—analyzes their pitfalls, and presents practical solutions such as delayed double‑delete, asynchronous retries, and binlog‑driven cache invalidation.
This article reviews various cache system types, compares popular distributed caches such as Memcache, Tair, and Redis, explains Redis cluster high‑availability mechanisms, discusses sharding strategies, and outlines common cache problems and solutions, providing practical configuration examples for Java backend developers.
This article explains cache consistency problems and solutions such as double‑delete and retry mechanisms, dives into Java fundamentals like HashMap internals and thread pools, and presents several backend interview coding questions with examples and code snippets.
This article explains why Redis needs persistence, describes the two main persistence mechanisms—RDB snapshots and AOF command logging—their configuration, internal structures, operational principles, and trade‑offs, and provides practical code examples for implementing and tuning them.
The article explains the concepts of cache penetration, cache breakdown, and cache avalanche in Redis‑based systems, analyzes the performance problems they cause under high concurrency, and presents practical mitigation techniques such as Bloom filters, caching empty objects, distributed locks, high‑availability clusters, rate limiting, and data pre‑warming.
This article explains how to design and implement a real-time ranking system for a mobile tank game using Redis sorted sets, covering leaderboard categories, composite scoring formulas, dynamic updates, data retrieval with pipelines, and provides a complete PHP class example.
Learn how to integrate Spring Data Redis with Spring Boot, replace Jedis with Lettuce, define data models using @RedisHash and @Indexed, configure connection properties, implement CRUD and example queries, and understand the underlying key-value storage patterns illustrated with practical code and visual examples.
Redis handles key expiration using commands like EXPIRE, PEXPIRE, EXPIREAT, and PEXPIREAT, offers TTL queries, and employs three deletion strategies—timed, lazy, and periodic scanning—while its eight eviction policies (e.g., volatile‑lru, allkeys‑lfu, noeviction) and refined LRU/LFU algorithms manage memory pressure efficiently.
This article explains how to use OpenResty with Lua to build a high‑performance caching layer that directly accesses Redis, compresses large responses, schedules periodic updates, forwards requests intelligently, and provides configurable URL caching, thereby improving concurrency, reducing latency, and optimizing bandwidth usage.
This article examines the challenges of implementing a flash‑sale (秒杀) system—such as overselling, massive concurrency, request flooding, URL exposure, and database strain—and presents a comprehensive backend design that includes dedicated databases, dynamic URLs, static page rendering, Redis clustering, Nginx load balancing, optimized SQL, token‑bucket rate limiting, asynchronous order processing, and service degradation strategies.
This article presents a complete Java utility class built on Jedis that simplifies Redis operations, covering connection handling, key management, and full support for strings, lists, hashes, sets, and sorted sets, with a link to the full source on Gitee.
This article explains why session sharing is critical in micro‑service architectures, compares common Nginx load‑balancing methods, and provides four practical solutions—ip_hash load balancing, Tomcat session replication, Redis‑based session caching, and cookie‑based sharing—complete with configuration examples and pros/cons.
This article explains the differences between thread, process, and distributed locks, describes how distributed locks work using third‑party storage such as Redis or Zookeeper, discusses implementation details, and highlights when and why to use them in backend systems.
This article recounts the author’s experience building a simple Java web application for a university anniversary, covering planning, environment setup, documentation, database design, coding challenges with Spring Boot, Redis, and session handling, deployment on Alibaba Cloud, and the lessons learned about architecture, logging, and monitoring.
This article examines how to ensure reliable message delivery in RabbitMQ by using durable queues, the confirm mechanism, and supplemental strategies such as persisting messages to Redis, implementing idempotent processing with optimistic locking or unique‑ID fingerprints, and employing compensation tasks to achieve near‑zero message loss in high‑concurrency systems.
This article demonstrates how to create a custom @AccessLimit annotation in Spring Boot, implement a rate‑limiting interceptor that checks request frequency via Redis, register the interceptor, and apply the annotation to controller methods to enforce request limits with optional login verification.
This article presents a comprehensive guide to using Redis for various backend scenarios, including caching hot data, sharing sessions, implementing distributed locks, generating global IDs, counting, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, tags, product filtering, follow relationships, and ranking, all illustrated with concrete code examples.
By illustrating how to replace simple HashMap caching with Redis‑based distributed caches and locks—using SETNX, Lua scripts, and Redisson—the article shows Spring Boot developers how to prevent cache breakdown, ensure data consistency, and dramatically improve throughput in high‑concurrency web applications.
This article examines common pitfalls in RabbitMQ message delivery, explains persistence and confirm mechanisms, and proposes a robust solution combining pre‑storage in Redis, confirm callbacks, scheduled retries, and idempotent processing to ensure virtually zero message loss in high‑concurrency systems.
This guide presents a comprehensive set of mandatory, reference, and recommended Redis usage standards—including command restrictions, key naming, data sizing, persistence configurations, monitoring, and deployment strategies—to improve performance, reliability, and operational efficiency for production environments.
This article demonstrates how to create a custom @AccessLimit annotation, implement a Spring Boot interceptor that checks Redis for request counts, register the interceptor, and apply the annotation to a controller method to enforce rate‑limiting with optional login verification.
This article outlines a variety of practical Redis use cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow/recommendation models, and ranking—demonstrating how Redis can support diverse backend functionalities.
This article explains the basic network programming pattern, introduces epoll as an I/O multiplexing solution for high‑concurrency servers, and demonstrates how Redis 5.0 integrates epoll through its event‑loop abstraction with detailed code examples and debugging tips.
To prevent duplicate OpenID records caused by concurrent synchronization requests in the Fast App Center, this article analyzes the root cause, evaluates database‑level unique indexes versus application‑level distributed locks, and presents a Redis‑based lock implementation with cleanup procedures to ensure data consistency.
This article documents a step‑by‑step performance optimization of a Python web module, covering requirement analysis, environment setup, load‑testing results, database and TCP bottleneck identification, caching strategies, kernel tuning, and the final achievement of 50,000 QPS with low latency.
This article reviews Redis 6.0 and 5.0 new features, compares cluster, master‑replica, and read‑write separation architectures, explains proxy and direct connection modes, and provides Java code for custom connection pools, helping you select the optimal Redis deployment for your workload.
This article explains how Redis implements the “nearby people” feature using its Geo module, detailing the GEOADD and GEORADIUS commands, their underlying algorithms, source‑code flow, and the resulting time‑complexity for adding and querying location data.
This article provides a comprehensive tutorial on preparing the development environment, configuring backend and frontend components, and launching a Jeecg‑boot powered logistics warehouse management system built with SpringBoot, Vue, MySQL, Redis, and related tools.
This article introduces the various Redis eviction strategies—including volatile-ttl, volatile-random, volatile-lru, volatile-lfu, allkeys-random, allkeys-lru, and allkeys-lfu—explains their behavior, shows where they are configured in redis.conf and the initServer source code, and notes the default noeviction policy when memory exceeds maxmemory.
This page aggregates over 300 curated interview question articles covering Java backend development topics such as Spring, MySQL, Redis, concurrency, data structures, and system design, organized by issue numbers to help candidates prepare effectively for technical interviews.
The article explains Redis's two expiration key removal mechanisms—lazy deletion, which removes keys only when accessed, and periodic deletion, which randomly scans and deletes expired keys at regular intervals—detailing their concepts, pros, cons, and underlying source‑code implementations.
This article explains why session sharing is needed in micro‑service architectures, outlines common Nginx reverse‑proxy strategies, and presents four practical solutions—Nginx ip_hash load balancing, Tomcat session replication, Redis centralized cache, and cookie‑based sharing—detailing their implementations and trade‑offs.
This guide explains Go’s built‑in testing framework, assertion libraries, table‑driven and sub‑tests, and demonstrates how to mock functions, structs, interfaces, databases, and Redis using tools such as ngmock, gomock, sqlmock and miniredis, while covering test setup, teardown, coverage handling, and best‑practice insights.
This article outlines the major new features of Redis 6.0 and 5.0, compares various deployment architectures—including master‑replica, cluster, and read‑write separation—explains proxy versus direct connection modes, and provides a Java Jedis connection‑pool code sample.
This article explains what Redis Sentinel is, its architecture, how to configure it in a master‑slave environment, and demonstrates handling of slave and master failures as well as setting up multiple Sentinel instances for high availability.
This article explains how to identify and resolve Redis slow queries by using the slow query log, understanding command complexity, replacing inefficient commands with more efficient alternatives, and configuring slowlog parameters for optimal performance.
This article thoroughly explains why distributed locks are needed, walks through basic Redis lock implementations, exposes deadlock and expiration issues, presents robust solutions with unique IDs and Lua scripts, examines the Redlock algorithm, reviews the Martin‑Antirez debate, and compares Redis with Zookeeper locks.
This article explains how Redis handles memory exhaustion by setting key expirations with commands like expire and pexpire, describes its lazy and periodic expiration strategies, details the eight configurable eviction policies, and dives into the internal LRU and LFU algorithms used for key eviction.
The article explains how to scale MySQL for massive traffic by combining Redis caching, read‑write splitting, data archiving, and sharding techniques, while highlighting their benefits, implementation steps, and potential consistency challenges in modern systems.
The article explains the concepts of cache penetration, cache breakdown, and cache avalanche in Redis‑based systems, describes the performance risks they pose to persistent databases, and presents practical mitigation techniques such as Bloom filters, empty‑object caching, hot‑key permanence, distributed locks, high‑availability clusters, rate limiting, and data pre‑warming.
This article explains how cache penetration occurs in high‑traffic systems and demonstrates how Bloom filters—using minimal memory and fast hash checks—can efficiently prevent such attacks, including construction details, Redis BitMap experiments, and Java Redisson implementation examples.
This article explains why message middleware guarantees at‑least‑once delivery, the challenges of duplicate consumption, and presents both simple and advanced deduplication strategies—including transactional and non‑transactional approaches using relational databases or Redis—to achieve effectively exactly‑once semantics in RocketMQ.
This article explains Redis's Simple Dynamic String (SDS) data structure, its internal layout, how it differs from traditional C strings, and the performance, memory‑reallocation, and data‑format benefits it brings to Redis's key‑value storage.
This article reviews Redis 6.0 and 5.0 new features, compares cluster, master‑replica (single and double replica), and read‑write‑separation architectures, explains their reliability and use‑case scenarios, and provides a Java/Jedis code sample for custom connection‑pool configuration.
The Fast App Center’s duplicate OpenID rows were traced to a non‑atomic check‑then‑insert race condition, prompting the team to evaluate a unique‑index safeguard versus application‑level distributed locking, ultimately implementing a Redis‑based lock to serialize inserts and adding a cleanup job to purge existing duplicates.
This article explains the Redis Simple Dynamic String (SDS) data structure, comparing it with traditional C strings, detailing its struct layout, O(1) length retrieval, pre‑allocation strategy, lazy space release, and provides code examples illustrating how SDS avoids buffer overflows and improves performance.
Discover a comprehensive Redis best‑practice guide covering memory optimization, performance tuning, high reliability, daily operations, resource planning, monitoring, and security, with actionable tips such as key length control, maxmemory settings, lazy‑free, connection pooling, replication strategies, and safe deployment practices.
This article reviews Redis 6.0 and 5.0 new features, compares deployment architectures such as cluster, master-replica, and read-write split, and provides Java connection-pool code examples to help engineers select the appropriate Redis setup for performance, reliability, and scalability requirements.
In distributed micro‑service environments, session sharing is essential to prevent repeated logins, and this article explains four practical solutions—Nginx ip_hash load balancing, Tomcat session replication, Redis‑based centralized sessions, and cookie‑based sharing—detailing their implementations, advantages, and drawbacks.
This article introduces a Java web application that integrates movies, music, and books, detailing its development environment, system architecture, core features such as login, search, and recommendations, and provides step‑by‑step deployment instructions along with the GitHub source link.
This article outlines a universal caching strategy for low‑frequency static data in microservice systems, explaining why in‑memory caches like Redis are needed, detailing a six‑component architecture with services, queues, and consistency checks, and weighing trade‑offs such as cache eviction, persistence, and scalability.
This article explains Redis's ziplist compressed list structure, its internal fields, lookup algorithm, performance characteristics, configuration thresholds for Hash and List types, and demonstrates a real‑world use case with memory‑saving calculations and experimental results.
The article explains why Java's synchronized lock cannot be used for distributed scenarios, demonstrates how to build a Redis‑based distributed lock with setIfAbsent, discusses pitfalls such as server crashes and lock expiration, and presents robust solutions including atomic expiration, thread‑ID verification, lock renewal, and Redisson usage.
This article explores the architecture and implementation of a high‑traffic ticket‑spike service, covering load‑balancing strategies, Nginx weighted round‑robin configuration, local and remote stock deduction using Go and Redis, fault‑tolerant buffering, and performance testing results.
This article explains how to use Redis's SCAN command to iterate over dictionary data, clean up stale keys, understand the command's underlying mechanics during dictionary resizing, and avoid common pitfalls through practical code examples and performance analysis.
This article explains Alibaba Cloud's Redis read‑write separation architecture, comparing star and chain replication models, their performance and scalability trade‑offs, and how transparent compatibility, high availability, and high performance are achieved through redis‑proxy, HA monitoring, and optimized binlog replication.
Redis achieves its remarkable speed through a combination of in‑memory data storage, optimized data structures like SDS, ziplist, quicklist and skiplist, a single‑threaded command model, efficient I/O multiplexing, and sophisticated persistence, replication, Sentinel and Cluster mechanisms that together ensure high performance and reliability.
This article examines the challenges of storing massive DMP data in Redis, analyzes memory fragmentation, key‑value explosion, and latency constraints, and presents practical solutions such as eviction policies, bucket hashing, key compression, and fragmentation reduction to enable efficient in‑memory storage.
This tutorial explains how to integrate Redisson into a Spring Boot application to implement robust distributed locks, covering Redisson's architecture, configuration, code examples, lock types, watchdog mechanism, and practical testing procedures for reentrant, read‑write, and semaphore locks.
This article explores how backend developers can handle intricate e‑commerce search filters by first attempting a monolithic SQL solution, then improving performance with index analysis and query splitting, and finally achieving fast, scalable results using Redis sets, sorted sets, and transaction commands.
This article explains how computers store text using binary, introduces ASCII, Unicode and UTF‑8 encoding rules, discusses the limitations of C‑style null‑terminated strings, and describes Redis's Simple Dynamic String (SDS) data structure, its old and new versions, advantages, and related APIs.
The article compares five practical methods—single‑server deployment, IP‑based restriction, database‑driven task selection, Redis expiration with distributed lock, and Quartz clustering—to ensure that a scheduled job runs only once across multiple servers, outlining each approach's advantages, drawbacks, and implementation details.
This article explains how to design a flash‑sale (秒杀) system that can handle massive traffic spikes by using static page CDN caching, gateway request interception, Redis inventory control, asynchronous order processing, and thorough business, deployment, and data isolation to ensure high performance and stability without affecting regular services.
This article demonstrates how to create a custom @AccessLimit annotation in Spring Boot, implement a rate‑limiting interceptor using Redis, register the interceptor, and apply the annotation to controller methods to restrict request frequency, with full Java code examples.
This article explores the HyperLogLog algorithm for cardinality estimation, tracing its development from Linear and LogLog counting, detailing its Redis implementation with sparse and dense encodings and command workflows, and presenting experiments that demonstrate its memory efficiency and analyze observed error rates versus the theoretical 0.81% standard deviation.
This article explains how to build a location‑based "nearby people" feature by storing coordinates in MySQL, filtering with rectangular bounds, calculating distances in Java, and then scaling the solution with Redis GEO using GeoHash and Sorted Sets for high‑performance proximity queries.
