This article explains how to build an online user counting feature using Redis sorted sets (ZSET) by detailing the core commands (zadd, zrangeByScore, zremrangeByScore, zrem), user identification methods, and providing Java and JavaScript code examples, while also noting unrelated promotional content at the end.
Redis, an open-source in-memory NoSQL database, is explored in depth covering its high-performance features, typical use cases, evolution, architecture, data types and commands, followed by an overview of Tencent Cloud Redis services and a brief advertisement for a DevOps certification program.
This article explains how to prevent duplicate API submissions by applying debounce principles and implementing distributed locks using Redis and Redisson in a Java Spring backend, providing detailed code examples, key generation strategies, and practical testing results.
The article analyzes the challenges of keeping MySQL and Redis data consistent under high concurrency, compares four write‑order strategies, explains why they can cause stale cache data, and presents recommended solutions such as Cache‑Aside, distributed locks, message queues, and Canal‑based binlog syncing.
This comprehensive guide explains Redis persistence mechanisms—including RDB snapshots, AOF write‑ahead logging, and their hybrid mode—covering their workflows, configuration options, replication processes, performance trade‑offs, and practical tips for reliable data durability.
In 2023, a TapTap infra team reduced Redis operating costs by 460,000 CNY per month through low‑cost ESSD instances, traffic compression, unused‑instance cleanup, TTL management, data migration, online compression, and targeted cleaning, detailing ten concrete measures and the open‑source tools that enabled zero‑downtime optimization.
This article surveys eleven Java‑based delayed‑task solutions—including DelayQueue, Timer, ScheduledThreadPoolExecutor, RocketMQ, RabbitMQ, Redis key‑expiration, Redisson, Netty’s HashedWheelTimer, Hutool SystemTimer, Quartz, and a simple polling loop—providing code demos, implementation principles, and practical pros and cons for each approach.
This article introduces lua‑resty‑redis, explains its non‑blocking I/O model, outlines typical use cases, details installation via OPM, provides step‑by‑step Lua code for basic operations and transactions, and demonstrates testing with curl, helping developers build high‑performance OpenResty services.
This guide demonstrates how to create a simple Go web API using the Gin framework, define a recipe data model, implement CRUD endpoints backed by MongoDB, add Redis caching for list queries, and provide a complete runnable example with testing scripts.
This article explores the benefits of short URLs, explains their redirection mechanics, compares hash‑based and auto‑increment generation methods, and presents a high‑throughput architecture using OpenResty, Redis, and MySQL to handle massive traffic while ensuring reliability and scalability.
The article examines why internet architectures have become increasingly complex, explains the unique challenges of flash‑sale (秒杀) business scenarios, and presents practical backend optimization techniques such as request filtering, Redis caching with atomic operations, ordered queues, data‑layer safeguards, and unit‑based isolation for global deployments.
Valkey, a Linux Foundation‑backed fork of Redis released under a BSD license, offers faster development, stronger community governance, and new performance and cloud‑native features, positioning it as a compelling alternative for modern workloads.
This guide explains how to implement an online user counting feature using Redis sorted sets, covering user identification methods, the essential zadd, zrangeByScore, zremrangeByScore, and zrem commands, along with code examples and a concise summary of the overall approach.
Explore nine major database technologies—from traditional relational MySQL to NoSQL Redis, columnar HBase and ClickHouse, document-oriented MongoDB, search engine Elasticsearch, graph Neo4j, time‑series Prometheus, and vector Milvus—plus practical best‑practice guides, real‑world polyglot persistence scenarios, and recommended resources for mastering modern data storage.
This tutorial explains how to leverage Redis Stack modules—especially RediSearch and RedisJSON—to store movie data, build a searchable JSON index, and perform advanced full‑text queries, highlighting, sorting, pagination, custom tokenization, scoring, and index aliasing, with Go code examples.
This article explains how to implement a Redis distributed lock, covering the basic SETNX approach, adding expiration, handling lock release errors with renewal and unique identifiers, achieving atomicity via Lua scripts, and discussing the inherent challenges of network delay, process pause, and clock drift in distributed systems.
This article explains how Redis handles memory exhaustion by configuring maxmemory and maxmemory-policy, detailing each eviction strategy (noeviction, volatile‑lru, volatile‑lfu, volatile‑ttl, volatile‑random, allkeys‑lru, allkeys‑lfu, allkeys‑random), their implementation details, and the underlying approximate LRU algorithm.
This article provides an in‑depth survey of nine database categories—including relational, key‑value, columnar, document, graph, time‑series, and vector databases—detailing their architectures, advantages, disadvantages, best‑practice recommendations, typical use cases, and how they can be combined in polyglot persistence solutions.
This guide walks through creating a lightweight SpringBoot cache component using custom @Cacheable and @CacheEvict annotations, configuring Redis, implementing an AOP aspect to handle caching logic, and demonstrating usage with sample services and controller endpoints, while also discussing key generation and potential enhancements.
The guide demonstrates how to build a front‑end/back‑end separated captcha login using Spring Boot, Kaptcha and Redis, showing Redis‑based captcha storage with a unique key, Base64 image delivery, and verification logic that replaces traditional session‑based approaches.
This tutorial walks you through using the Lock4j distributed lock component in Spring Boot 3.2.5, covering its features, Maven dependencies, configuration, basic annotation usage, custom key generation, expiration settings, and advanced options like custom executors, key builders, failure strategies, and manual lock handling.
This article explains the causes of Redis cache‑database inconsistency, cache avalanche, breakdown, and penetration, and provides practical strategies such as synchronous writes, delayed double deletion, expiration tuning, circuit breaking, rate limiting, and Bloom filters to keep systems stable.
This article explains how Redis achieves extremely high throughput—over 800 k QPS for simple commands and up to 1 M QPS with pipelining—through its C implementation, in‑memory data store, single‑threaded event loop, I/O multiplexing, and optional multithreaded I/O introduced in later versions.
This article introduces Lock4j, a versatile Java distributed‑lock component supporting RedisTemplate, Redisson and Zookeeper, explains its key features, shows how to add dependencies and configure Redis, details the @Lock4j annotation attributes, provides simple and advanced usage examples with code snippets, and demonstrates custom executors, key builders, failure strategies, and manual lock handling.
This article explains how to track online users by assigning each user a unique identifier, storing it in a Redis sorted set with an expiration timestamp, and using zadd, zrangeByScore, zremrangeByScore, and zrem commands together with browser fingerprinting to reliably count and clean up active sessions.
This comprehensive guide walks you through Shiro's core concepts, authentication and authorization mechanisms, various realm implementations, session management, distributed session handling with Redis, caching strategies, and step‑by‑step integration of CAS single sign‑on using SpringBoot and pac4j, complete with code samples.
This article explains how to implement distributed locks using Redis, starting with a simple SETNX approach, identifying its shortcomings, and then presenting solutions such as thread‑identifiers, Lua scripts for atomicity, handling TTL with watchdogs, the RedLock algorithm, and practical usage via the Redisson Java client.
This article explains how to implement distributed locks using Redis, starting with a basic SETNX approach, identifying its shortcomings, and then presenting robust solutions such as identifier‑based unlocking, Lua scripts for atomicity, the RedLock algorithm, and Redisson’s advanced features including a watchdog mechanism.
Redis’s core operations run on a single thread to avoid concurrency overhead, while auxiliary tasks use extra threads; the article explains the single‑threaded model, Linux I/O multiplexing (select/epoll), Redis 6.0’s I/O thread feature, and practical configuration steps to improve throughput.
This article analyzes the challenges faced by Ctrip's ticket‑booking transaction system during high‑traffic flash‑sale events and presents a series of architectural optimizations—including Redis caching, database load mitigation, supplier‑system safeguards, and fine‑grained traffic‑control strategies—to achieve stable, consistent, and fast performance under extreme concurrency.
This article compares Memcached, Redis, and Aerospike across persistence, replication, performance, memory management, and use‑case scenarios to help you select the most suitable in‑memory database for high‑throughput, low‑latency applications.
This article explains how Redis achieves tens of thousands of QPS on average hardware, breaks down the technical reasons behind its speed—including C implementation, in‑memory design, epoll‑based I/O multiplexing, and a single‑threaded event loop—while also detailing the evolution to multithreaded I/O in later versions.
This article explains the concept of request debouncing, outlines ideal debounce component characteristics, identifies which API endpoints need debouncing, and provides detailed Java implementations using shared Redis cache and Redisson distributed locks, including custom annotations, key generation, and practical testing results.
This article details the architecture, business value, configuration, storage choices, performance challenges, and future plans of Bilibili's live streaming ranking system, explaining how it uses MySQL and Redis, supports automated scoring, and handles high‑traffic read/write demands.
This article details a step‑by‑step investigation of a JSF thread‑pool exhaustion error that occurred when upgrading the Redis version of JD's internal R2M distributed cache, analyzing stack traces, lock contention, ForkJoinPool behavior, and the eventual remediation steps.
This article details Uber's Docstore distributed database challenges and explains the design, architecture, and implementation of CacheFront—a transparent, high‑performance caching layer that reduces latency, improves scalability, and maintains strong consistency across microservices.
This article explains how Redis operates primarily with a single‑threaded model for memory and network operations, why this design is efficient, and how recent versions introduce multi‑threaded components for network I/O, persistence, and asynchronous deletion while preserving thread safety.
This article explains the concept of cache preheating, provides an abstract cache class, a Spring ApplicationContext utility, a CommandLineRunner handler to load hot data at startup, and demonstrates a concrete NewsCache implementation with Redis integration, followed by a REST endpoint to access the cached data.
This guide walks backend developers through twenty real‑world Redis use cases—from basic caching, lotteries, and like/collect features to ranking, PV/UV counting, Bloom filters, sign‑in, geo‑search, rate limiting, ID generation, distributed locks, messaging, session sharing, and more—providing Spring Boot code samples, limitations, and best‑practice advice.
An in‑depth guide to backend caching covers read‑through and cache‑aside strategies, local versus distributed caches (including Redis and Memcached), eviction algorithms such as FIFO, LRU and LFU, and tackles consistency, avalanche, penetration and breakdown issues with practical mitigation techniques.
This article explores eleven practical methods for implementing delayed tasks in Java, covering native APIs like DelayQueue and Timer, advanced executors such as ScheduledThreadPoolExecutor, and popular messaging solutions including RocketMQ, RabbitMQ, Redis, Redisson, Netty, Hutool, and Quartz, with code demos and implementation details.
This article walks through creating a distributed instant‑messaging system in Go, covering the full tech stack, Docker‑based and local startup methods, configuration files, the end‑to‑end request flow, and detailed code examples for RPC, Redis queues, WebSocket delivery and the internal bucket architecture.
This article details the design and implementation of a Java SpringBoot seckill system, covering its architecture, technology stack, double‑MD5 password encryption, distributed session management with Redis, unified exception handling, page and object caching, static page generation, memory‑flag plus Redis pre‑decrement and RabbitMQ asynchronous order processing, oversell prevention, and API rate limiting, accompanied by key code snippets.
This article walks through a real‑world Redis latency incident, detailing systematic troubleshooting steps, key metrics to monitor, command‑line diagnostics, and practical optimizations such as scaling, pipelining, and hot‑key mitigation to restore service performance.
This article explains why Redis achieves extremely high performance, reaching up to 100,000 QPS, by leveraging its in‑memory design, I/O multiplexing, optimized data structures such as SDS, ziplist and skiplist, and a single‑threaded event loop, each detailed with examples and code.
This article explains how to prevent duplicate submissions in Java backend services by implementing request debouncing using custom annotations, Redis-based locks, and Redisson distributed locks, covering key generation, lock acquisition, configuration, and testing to ensure idempotent API calls.
This article explains the concept of idempotency, identifies which HTTP requests are naturally idempotent, discusses why idempotency is essential for retries, async callbacks, and message queues, and demonstrates a practical Java implementation using custom annotations, AOP, and Redis for token management.
This article explains the concept of interface debouncing, identifies which API endpoints need it, and provides detailed Java implementations using custom @RequestLock annotations, Redis caching, and Redisson distributed locks to prevent duplicate submissions in backend services.
This article explains the cache‑stampede problem when hot Redis keys expire under massive traffic, illustrates why simple caching fails, and presents a mutex‑lock solution with Go code to safely rebuild caches while protecting the database.
To maintain data consistency between Redis caches and MySQL databases, this article examines common pitfalls and presents three robust solutions—deleting cache before DB writes, updating the DB then removing cache, and implementing delete‑retry mechanisms—plus optional locking for strong consistency.
The article explains how Redis achieves high QPS by using an in‑memory, single‑threaded event loop for simple commands, leverages I/O multiplexing (epoll/select/kqueue) and optional multi‑threaded I/O for heavy operations, and outlines its evolution from a pure reactor model to a hybrid multi‑threaded architecture.
This article explains why cache‑DB consistency is a long‑standing challenge, compares naive full‑load and delete‑cache approaches, analyzes concurrency and failure scenarios, and presents reliable solutions such as updating the database first followed by cache deletion using message queues or binlog subscriptions.
This article describes how a unified membership system serving billions of users across multiple platforms achieves high performance and high availability through dual‑center Elasticsearch clusters, traffic isolation, deep ES optimizations, Redis caching, dual‑center MySQL partitioning, seamless migration, and fine‑grained flow‑control and degradation strategies.
This article explains the relationship between MySQL and Redis, discusses why cache consistency is challenging, and details four cache update design patterns—delete‑then‑update, update‑then‑invalidate (Cache‑Aside), read/write‑through, and write‑behind—illustrating each with flow diagrams and practical considerations.
This article explains how Redis as a distributed cache can cause data inconsistency with relational databases during write operations, outlines read and update workflows, compares five cache‑update strategies, and presents a delayed double‑delete solution with sample code to maintain consistency.
This tutorial explains how PHP developers can install PECL, search for and install extensions such as Redis, and integrate them into PHP code, while highlighting configuration steps and best practices for reliable backend development.
This article walks through the problem of traditional session‑based captcha login, compares it with a modern front‑back‑separated architecture, and provides a step‑by‑step implementation using Spring Boot, Kaptcha, and Redis, including full code snippets, configuration classes, and flow diagrams.
This article introduces RedisInsight, outlines its key features, provides step‑by‑step instructions for installing it on Linux and via Kubernetes—including environment variable configuration and service deployment—and demonstrates basic usage through screenshots of its GUI.
This article explores fundamental PHP caching techniques—including OPcache, HTTP header client caching, Memcached/Redis object caching, reverse‑proxy page caching, dynamic content caching, and cache invalidation—providing code examples and practical guidance to help developers dramatically improve application performance and scalability.
This article explains how to track online users by storing their identifiers in a Redis sorted set, using zadd to add entries, zrangeByScore to query active users, and zremrangeByScore and zrem to clean up expired or logged‑out sessions, with code examples in Java and JavaScript.
This article explains how to prevent duplicate API calls in Java backend systems by using debounce techniques, shared Redis caches or Redisson distributed locks, and provides complete annotation‑based implementations with code examples, key generation strategies, and testing results to achieve idempotent interfaces.
This article explains Redis bitmap data structures, introduces common bitmap commands such as BITSET, BITGET, and BITCOUNT, and provides a complete PHP example that records user sign‑ins and calculates daily sign‑in counts using Redis bit operations.
This article explains the motivation, design principles, class diagram, and core Go code for a multi‑level cache library that supports in‑memory and distributed caches (Redis, Memcached) using adapter, builder, and responsibility‑chain patterns, and discusses cache‑database consistency strategies.
This article introduces Redisson as a Redis Java client and demonstrates how to use its distributed collection implementations—RMap, RSet, RList, RQueue, and various blocking queues—in Spring Boot 2.7, covering synchronous, fast, and asynchronous operations, lock binding, local caching, and event listeners.
Redis announces a dual‑license model (RSALv2 and SSPL) starting with version 7.4, sparking community backlash, prompting concerns about open‑source status, potential distro removals, and driving users toward alternative in‑memory databases and possible forks.
This article explains the concept, use cases, and common implementations of delay queues—including JDK's DelayQueue, RabbitMQ plugins, and Redis ZSet—followed by a detailed guide to installing, configuring, and using the open‑source lmstfy project, and concludes with promotional information for ChatGPT‑related services.
Ensuring API idempotency is crucial to avoid duplicate operations like double crediting points or double payments, and this article examines common causes of repeated calls—such as rapid user clicks, retries, and message queues—and presents practical backend solutions including frontend controls, Redis setnx, token validation, unique indexes, counting, and state machines.
This article explains how to achieve reliable API idempotency in Spring Boot applications by using Redis for token storage, defining a custom @AutoIdempotent annotation, implementing token generation and validation services, configuring an interceptor, and providing test cases to demonstrate the workflow.
This article outlines seven typical cache problems—including cache penetration, breakdown, avalanche, large keys, hot keys, hit‑rate issues, and data inconsistency—and provides practical solutions such as parameter validation, Bloom filters, null‑value caching, locking, auto‑renewal, random expiration, high‑availability setups, compression, and cache warming to improve system reliability and performance.
This article explains how to design and implement a fast, shared‑memory cache for a PHP‑based strategy game backend using Webman, Redis, MySQL, and APCu, covering service architecture, Redis usage, atomic operations with APCu locks, channel and list mechanisms, and practical code examples for multi‑process communication.
The article explains why API debounce is essential, identifies the types of endpoints that need it, and walks through two SpringBoot solutions—Redis‑based shared cache and Redisson distributed lock—complete with custom annotations, key generation, code samples, test results, and practical limitations.
The article recounts a painful production incident caused by missing cache warm‑up, explains why pre‑loading caches is essential for performance and reliability, and presents practical strategies such as gray‑scale rollout, database scanning, and ETL‑driven cache filling.
The article analyzes common inventory‑deduction scenarios, compares three approaches—single‑row MySQL, multi‑row MySQL, and Redis INCRBY—highlights the limitations of database‑based methods under heavy load, and presents a robust Redis‑Lua solution with distributed locking and Java code examples for reliable stock management.
This guide explains how to download and install the Redis extension, add the Predis package to a Laravel project, configure single‑node and clustered Redis connections in config/database.php, and demonstrates basic Redis commands, transactions, and Lua scripting within Laravel controllers.
This article examines Pinterest's evolution through four development phases, the core technologies it adopted, and how it transitioned from complex clustering to a simpler sharding architecture to achieve scalable, high‑availability data storage.
This tutorial explains how Redis Cluster automatically shards data across multiple nodes, covering required TCP ports, hash‑slot sharding, master‑slave replication, consistency trade‑offs, essential configuration parameters, and step‑by‑step commands for creating, expanding, resharding, and managing a production‑grade Redis cluster.
This guide explains how to implement a Retrieval‑Augmented Generation (RAG) workflow by loading a beer‑info JSON dataset into a Redis vector store, wiring it with Spring Cloud Alibaba AI Starter, and exposing a web API that returns LLM‑generated answers.
This article explains the essential elements of high‑concurrency system design—performance, availability, scalability—introduces quantitative metrics, classifies read‑heavy and write‑heavy scenarios, and details practical solutions such as database read/write separation, local and distributed caching, cache‑penetration and avalanche mitigation, and CQRS implementation for billion‑user applications.
This course provides an in‑depth exploration of core backend concepts, covering process fundamentals, TCP/IP socket communication, Nginx integration with PHP‑FPM via FASTCGI, host‑to‑network byte order conversion, and Redis basics, aiming to equip developers, sysadmins, and network engineers with comprehensive backend development skills.
This article explains the motivation, architecture, resource estimation, code generation algorithms, data modeling, database partitioning, caching strategies, and implementation details for building a scalable short URL system that handles billions of links and high QPS workloads.
The article explains several common reasons why Redis may degrade performance—such as network latency, misuse of high‑complexity commands, the KEYS command, clustered key expirations, and big‑key operations—and provides practical mitigation techniques like batch commands, TTL randomization, and lazy deletion.
This article introduces a Spring Boot starter that provides a ready‑to‑use Redis utility suite—including common tools, distributed locks, message queues, delay queues, pagination queries and web helpers—explains how to add the Maven dependency, configure modules via YAML, and details the internal auto‑configuration and bean implementations for MQ and delayed messaging.
This article explains common Redis performance pitfalls—including per‑command network latency, expensive commands like SUNION and KEYS, mass key expiration spikes, and big‑key deletions—and provides practical techniques such as MSET batching, randomizing expirations, and using UNLINK to keep your backend fast.
This article compares six practical backend approaches—JDK DelayQueue, RocketMQ delayed messages, Redis expiration, Redis Zset, a dedicated task center, and passive closure—to automatically close unpaid e‑commerce orders after a configurable timeout, outlining their advantages, drawbacks, and suitable scenarios.
Redis announced that starting with version 7.4 it will adopt a dual‑source licensing model (RSALv2 and SSPL), moving away from its permissive BSD‑3 license, sparking widespread community backlash, discussions about cloud provider restrictions, and prompting users to consider alternative databases or forks.
The article introduces go‑sniffer, a Go‑based packet sniffer that captures MySQL, Redis, and MongoDB traffic, explains how to install required dependencies and the tool itself on CentOS or Ubuntu, and provides command‑line examples for auditing and analyzing database operations.
RediSearch, a Redis module providing full-text search and secondary indexing, is introduced with its features, performance comparisons against Elasticsearch, benchmark results for index building and query throughput, detailed installation methods, and extensive command examples for creating, querying, updating, and managing indexes.
This article explains Redis databases, the structure of the keyspace, how to set key expiration, and the various memory reclamation and eviction policies, providing Java developers with the essential knowledge needed for advanced Redis interview questions.
The article details Bilibili’s live ranking system, explaining how configurable ranking lists—managed via a console, stored in MySQL and cached in Redis zsets—support diverse dimensions, scoring modes, and filters to boost streamer and viewer engagement, while addressing high traffic, reliability, and future scalability plans.
The article reviews Amazon MemoryDB, a Redis‑based in‑memory database that uses a distributed transaction log to achieve strong consistency and durable persistence for high‑throughput, latency‑sensitive workloads, and compares its architecture and performance with open‑source Redis.
This article explains the fundamentals of finite‑state machines, introduces Spring Statemachine’s core features, walks through a complete Java implementation with database schema, persistence (memory and Redis), REST APIs, exception handling, and an AOP‑based solution for reliable state transitions.
This article analyzes feed‑timeline architectures, compares pull‑based and push‑based models, proposes an online‑push/offline‑pull hybrid, and details practical implementations using Redis SortedSets, multi‑level caching with Cassandra, cursor‑based pagination, and large‑scale push task sharding.
This article systematically examines seven typical cache problems—penetration, breakdown, avalanche, data inconsistency, big‑key, hot‑key, and low hit rate—explaining their root causes, illustrating concrete scenarios with diagrams and code, and presenting step‑by‑step mitigation techniques such as parameter validation, Bloom filters, locking, auto‑renewal, random expirations, high‑availability setups, and cache warm‑up.
This article explains the principles of Redis Pipeline, compares Lettuce and Redisson client implementations in Spring Boot, presents performance tests showing dramatic speed gains over single commands, discusses practical usage scenarios, common pitfalls, and provides detailed source code examples for both clients.
This article walks through Redis's architectural journey—from a lone instance to a high‑availability, high‑performance cluster—covering persistence (RDB, AOF, hybrid), master‑slave replication, Sentinel automatic failover, sharding strategies, and the modern Redis Cluster design.
This article walks you through Redis’s architectural journey—from a simple single‑node setup, through persistence mechanisms, master‑slave replication, Sentinel‑driven automatic failover, and finally sharding with Redis Cluster—explaining each component’s purpose, trade‑offs, and how they collectively boost performance and reliability.
This article explains three common methods for implementing delayed queues with Redis—using key expiration notifications, Zset with scheduled tasks, and Redisson’s RDelayedQueue—detailing their concepts, core code examples, advantages, and limitations for backend developers.
This article explains how to design a high‑QPS hotspot data caching and retrieval system for e‑commerce homepages using OpenResty, Lua, Redis, and a message queue, detailing publishing, reading processes, workflow diagrams, and a complete Lua script that can sustain tens of thousands to millions of concurrent requests.
This article explains the concept of delayed queues, compares them with scheduled tasks, outlines common business scenarios, and provides a complete Redis implementation using Sorted Sets, Lua scripts, and PHP code, including producer and consumer examples and performance considerations.
This article explains how to build a multi‑level caching system for microservice applications, covering client‑side HTTP caching, CDN and Nginx static‑resource caching, in‑process and distributed Redis caches, consistency challenges, and practical guidelines for when such a design is beneficial.
