This article introduces a collection of practical Redis use cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, product filtering, follow relationships, and ranking—explaining their data types, commands, and sample code.
The article explains why session sharing is critical in micro‑service and distributed deployments and presents four backend solutions—Nginx ip_hash load balancing, Tomcat session replication, Redis‑based centralized session storage, and cookie‑based sessions—detailing their implementations, advantages, and drawbacks.
Learn the essential Redis monitoring metrics—including performance, memory, activity, persistence, and error indicators—along with the commands and tools such as redis-cli, INFO, SLOWLOG, and redis-benchmark to collect, interpret, and act on these metrics for effective database operations.
This article provides a comprehensive list of typical Redis interview questions covering its features, performance, data structures, supported data types, common use cases, eviction policies, persistence methods, clustering, high‑availability mechanisms, transaction handling, and comparisons with local caches like Guava and Caffeine.
This article presents a detailed multi‑threaded performance benchmark of Redis list commands using the FunTester framework, describing three test scenarios, Java implementation details, raw JSON results, and observations on QPS and latency for insert, pop, and combined add‑remove operations.
This article examines the fundamental characteristics of Redis, explains why network latency often dominates performance, and presents practical optimization strategies such as using Unix IPC, multi-key commands, transactions, scripts, pipelining, avoiding slow commands, tuning persistence, adjusting OS settings, and adopting distributed architectures to achieve higher throughput and lower latency.
This guide walks through deploying a SpringBoot‑Vue split‑stack project with Docker by creating separate containers for Redis and MySQL, building custom Docker images for the backend JAR and the Nginx‑served frontend, configuring host networking, and exposing the necessary ports for verification.
This article explores sixteen practical Redis use cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, product filtering, follow relationships, and ranking—detailing data types, commands, and code snippets for each scenario.
This article presents a detailed interview-style walkthrough of Redis fundamentals, covering its thread model, persistence mechanisms (AOF, RDB, hybrid), command behaviors, high‑availability options, and the hash‑slot based clustering algorithm, illustrated with code snippets and diagrams.
The article presents DB‑Engines' September 2021 ranking of 378 databases, analyzes trends such as the rise of domestic systems, highlights leading time‑series and key‑value databases, and announces a community book‑giving event with ten recommended database titles.
This article analyzes the at‑least‑once guarantee of message middleware, explains why duplicate deliveries occur, compares simple database‑based deduplication methods, explores concurrency challenges, and presents a non‑transactional, status‑driven idempotence solution using MySQL or Redis with practical code examples and limitations.
This article details Ctrip Finance's design and implementation of a unified high‑availability Redis‑based distributed cache, covering eventual and strong consistency scenarios, multi‑region deployment, lock mechanisms, message‑driven updates, failure handling, and performance results.
The September 2021 DB‑Engines ranking shows longtime leaders Oracle, MySQL and Microsoft SQL Server losing hundreds of points, while MongoDB, Snowflake and ClickHouse surge in popularity, Redis and InfluxDB dominate their niches, and the report stresses that selecting a database should prioritize business needs over mere ranking.
This article explains how to handle multi‑gigabyte video uploads by splitting files into chunks, using MD5 for identification, implementing resumable and instant uploads with Spring Boot and Redis, and leveraging Java's RandomAccessFile and memory‑mapped I/O for efficient merging.
This article walks through a practical performance test for continuously adding key‑value pairs to Redis using the FunTester framework, detailing the test design, Java and Groovy implementations, execution logs, result metrics, and key takeaways for future Redis benchmarking.
This article explains the fundamentals of data consistency in distributed systems, compares strong, weak, and eventual consistency, describes three classic cache patterns (Cache‑Aside, Read‑Through/Write‑Through, Write‑Behind), and presents practical techniques such as delayed double delete, retry mechanisms, and binlog‑based asynchronous deletion to keep Redis caches and MySQL databases in sync.
This article explains the concept of delayed tasks, compares them with scheduled tasks, and presents five practical implementation strategies—including database polling with Quartz, JDK DelayQueue, Netty's time‑wheel algorithm, Redis sorted‑set and keyspace notifications, and RabbitMQ delayed queues—complete with code samples, advantages, and drawbacks.
The article explains how to protect a flash‑sale inventory using Redis locks in a Spring Boot service, starting with a simple synchronized lock, moving to distributed locks with setIfAbsent, handling lock expiration issues, extending TTL, and finally simplifying the implementation with Redisson.
This guide explains how to install, configure, and use the @midwayjs/task module for distributed and delayed task scheduling in Midway, covering Redis setup, code examples for cron jobs, local tasks, manual triggers, progress tracking, logging, and troubleshooting.
This article introduces the main Redis scaling solutions—including simple partitioning, master‑slave replication, Sentinel high‑availability, and Redis Cluster—explaining their concepts, usage patterns, advantages, and drawbacks to help developers choose the appropriate architecture for high‑traffic environments.
This article explains how a naïve SpringBoot SecKill implementation can cause overselling, then introduces Redis commands (SETNX, EXPIRE, GETSET) and a custom RedisLock component to achieve safe distributed locking, avoid deadlocks, and ensure accurate inventory updates during high‑concurrency flash‑sale events.
The article explains the concept of delayed tasks versus scheduled tasks and presents five practical Java implementations—database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets and keyspace notifications, and RabbitMQ delayed queues—detailing their code, advantages, and drawbacks.
This article explains the motivation for client‑side caching, what data should be cached, and details the Redis tracking feature—including normal, broadcast, and redirect modes—while providing implementation examples and best‑practice guidelines for reducing latency and load on Redis servers.
This article explains how to extend Redis beyond a single instance by covering partitioning, master‑slave replication, Sentinel automatic failover, and Redis Cluster, describing their usage methods, advantages, and drawbacks for high‑traffic, high‑availability scenarios.
This article analyzes common like‑system business scenarios, derives functional requirements, proposes three architectural solutions (Redis‑based priority queue, relational database, and a hybrid cache‑MQ‑DB design), presents detailed implementation code, and evaluates each approach with extensive performance tests to guide practical backend design choices.
This article examines the consistency challenges when using Redis as a cache for database data, compares three update strategies, and presents practical solutions such as delayed double‑delete, retry mechanisms, and handling cache penetration, avalanche, and thread‑safety issues in Java.
This article explains what distributed locks are, outlines their essential properties, walks through step‑by‑step Redis implementations—from simple SETNX to Lua‑based atomic operations—and discusses reliability strategies such as master‑slave failover and RedLock while highlighting the inherent limits of any distributed lock.
This article explores the challenges of storing billions of mapping records for a DMP in Redis and presents practical solutions such as eviction policies, key bucketing, hash‑map optimization, fragmentation reduction, and specialized memory allocators to achieve millisecond‑level real‑time queries.
This article explains why Redis can be slow when used for delayed processing, shows how to implement a delayed queue with Redis ZSET, compares its advantages, and reviews alternative solutions such as RabbitMQ, RocketMQ, Kafka, Netty, and Java's DelayQueue.
This article explains various approaches to implementing delayed tasks in backend systems, comparing database polling, Java's DelayQueue, Netty's time wheel, Redis sorted sets and keyspace notifications, and RabbitMQ delayed queues, with detailed code examples and analysis of each method's pros and cons.
This article compiles 20 classic Redis interview questions covering its definition, data structures, performance mechanisms, caching challenges, high‑availability setups, persistence options, distributed locking techniques, and best‑practice solutions, providing developers with comprehensive insights into Redis architecture and practical usage.
This article compares delayed and scheduled tasks, explains their differences, and presents five practical Java implementations—including database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets, and RabbitMQ—highlighting each method's advantages and drawbacks.
This article explains what Redis Sentinel is, its architecture, how to configure sentinel.conf, monitor master and slaves, handle slave and master failures, and set up multiple sentinel instances for robust high‑availability in a Redis master‑slave environment.
This article compares delayed tasks with scheduled tasks and presents five practical Java implementations—database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets and keyspace notifications, and RabbitMQ delayed queues—detailing their code, advantages, and drawbacks.
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.
