This article examines common failure scenarios of Redis‑based distributed locks, compares a simple lock implementation with the Redlock algorithm, and provides practical solutions for single‑point failures, lock expiration issues, clock drift, and high‑concurrency pitfalls.
This article walks through seven practical Laravel techniques—including view composers for reusable sidebars, route naming for maintainable URLs, dynamic key‑value settings, concise database query shortcuts, polymorphic relationships, caching best practices, and separating Redis connections—to help developers write cleaner, more scalable backend code.
This article explains the three Redis expiration‑key deletion strategies—timed, lazy, and periodic—their advantages and disadvantages, how Redis implements lazy and periodic deletion, and how persistence mechanisms such as RDB, AOF, and replication handle expired keys.
This tutorial explains Redis bitmap operations, covering SETBIT, GETBIT, BITCOUNT, and BITOP commands, their syntax, underlying SDS structure, time‑complexity analysis, memory‑size calculations, and practical scenarios such as user sign‑in tracking and online‑user statistics.
Learn how to dramatically boost Redis speed by shortening key/value sizes, enabling lazy free, setting expirations, disabling costly commands, using slowlog, pipelines, avoiding mass expirations, optimizing clients, limiting memory, running on physical servers, tweaking persistence, disabling THP, and adopting distributed architectures.
This guide walks you through configuring Kibana visualizations, customizing Nginx and Apache logs in JSON, setting up Logstash pipelines, integrating Redis as a buffering queue, and deploying a production-ready ELK stack for efficient log management and analysis.
This article explains how to implement automatic idempotency for Spring Boot APIs using Redis, a custom @AutoIdempotent annotation, token generation and verification, and an interceptor, providing step‑by‑step code examples and a testing workflow to prevent duplicate operations.
This article explains how Redis implements two persistence mechanisms—RDB snapshots and AOF logs—covering their triggers, execution flows, advantages, drawbacks, differences, restart recovery procedures, and practical ways to mitigate performance overhead caused by fork operations.
This article explains the design of Redis Cluster, the challenges of migrating clients, and how the Camellia-Redis-Proxy middleware—built with Netty—provides transparent proxying, sharding, dual‑write, plugin support, and performance optimizations such as multithreading, async I/O, pipelining, and robust error handling.
This guide explains how to install Redis clients, configure single and clustered connections, customize Predis and PhpRedis options, and use Laravel's Redis facade for basic commands, pipelining, multiple connections, and publish/subscribe messaging, all with clear code examples.
This article explains how to build a highly available Redis service by analyzing failure scenarios, comparing single‑instance, master‑slave with one or multiple Sentinel processes, and finally presenting a three‑Sentinel architecture that ensures continuous service despite node or network outages.
This article explains the principles, design considerations, and code implementation of Redisson's distributed lock, covering mutual exclusion, deadlock prevention, performance, reentrancy, watchdog auto‑extension, Lua scripting, and potential pitfalls in Redis sentinel setups.
This article explains how to implement automatic API idempotency in Spring Boot using Redis for token storage, custom annotations, and interceptor configuration, covering token generation, validation, Redis service utilities, and testing with Postman to prevent duplicate operations and ensure data consistency.
This tutorial walks through pulling the Redis Docker image, creating configuration files, running the container, connecting with redis-cli, testing commands, enabling persistence, and installing a visual management tool, providing complete step‑by‑step instructions for Docker‑based Redis deployment.
Learn how to dramatically improve Redis performance by shortening key-value sizes, enabling lazy free, setting expirations, disabling costly commands, using slowlog, leveraging pipeline, preventing mass expirations, optimizing client connections, limiting memory, running on physical servers, configuring persistence, disabling THP, and adopting distributed architectures.
This article explains why Redis performance matters for high‑traffic services and provides a comprehensive set of practical optimizations—including network latency reduction, command pipelining, avoiding slow commands, tuning persistence, OS/hardware settings, and scaling with sharding—to help you keep Redis fast and reliable.
This guide walks you through setting up a six-node Redis cluster using Docker Compose, configuring the necessary redis.conf settings, deploying the containers, initializing the cluster, and then integrating the cluster into a SpringBoot application via appropriate application.yml configurations and connection commands.
This article explains how to design and implement a Redis‑driven, second‑level scheduled‑task cluster that reliably pushes millions of coupon notifications in real time, addressing latency, throughput, and single‑point‑failure challenges.
This article explains why cache penetration occurs in high‑dimensional data scenarios, introduces Bloom Filters as a solution, outlines suitable use cases such as database lookups, cache outages, web request filtering, malicious URL detection and Bitcoin sync, and details practical Redis‑based implementations, advantages, drawbacks, and advanced counting filter techniques.
This article explains Redis's memory model by describing how to query memory usage, the roles of used_memory, used_memory_rss, mem_fragmentation_ratio, and mem_allocator, and then dives into the internal structures such as redisObject, SDS, jemalloc, and the encoding strategies for strings, lists, hashes, sets, and sorted sets.
This article provides a comprehensive guide to Redis, covering atomic transactions, command pipelining, publish/subscribe messaging, data replication, high‑availability with Sentinel, and the distributed architecture of Redis Cluster, complete with code examples and configuration steps.
This guide explains how to use Zabbix's auto‑discovery feature to automatically find Redis instances on a server, create shell or Python scripts for port detection, configure Zabbix agent keys, set up server‑side templates, discovery rules, item prototypes, graphs, and triggers, and finally apply the template to monitored hosts.
This article explores the design of a high‑performance short‑link system, covering its benefits, redirection mechanics, hash‑based and auto‑increment generation methods, database schema, Bloom filter optimization, and a scalable OpenResty‑based architecture for handling massive traffic.
This article presents ten practical Redis best‑practice guidelines—from avoiding the costly KEYS * command and leveraging SCAN, to using INFO for command statistics, employing hashes, setting expirations, selecting eviction policies, handling errors, scaling with clusters, understanding threading limits, and configuring Sentinel for high availability.
Learn how to resolve performance bottlenecks in a Spring‑based mall project by caching user and permission data in Redis, adding cache logic with RedisTemplate, and using AOP to gracefully handle Redis failures, ensuring stable authentication even when the cache is unavailable.
This article walks through the evolution of a Redis‑based cache layer for multi‑data‑center deployments, addressing consistency, safety, performance, disk‑space, data loops, timestamp versioning, master‑slave failover, and global numeric aggregation, and culminates in a ready‑to‑use middleware solution.
This article explains the internal implementations of Redis’s five major data structures—simple dynamic strings (SDS), linked lists, dictionaries, skiplists, integer sets, and ziplists—detailing their definitions, memory layouts, key characteristics, and how Redis leverages them for high‑performance storage and retrieval.
This comprehensive guide walks you through installing Redis on Linux and Windows, configuring Spring Cache annotations, setting up JSON serialization with RedisTemplate, using connection pools, and implementing a flexible RedisService with controller examples, providing all the essential steps to integrate Redis into your Spring Boot applications.
The article reviews a Tencent Cloud TVP closed‑door forum where experts compared MySQL 8.0, PostgreSQL, Redis and the cloud‑native CynosDB, highlighting each product’s technical strengths, ecosystem support, and the broader industry trend toward cloud‑native, multi‑database solutions as the future of data management.
The Redis website experienced an unexpected outage caused by an OOM error due to insufficient memory on a low‑cost DigitalOcean droplet, and the maintainer quickly fixed it by upgrading the instance and limiting allkeys‑lru usage, revealing surprising details about the site’s infrastructure.
On March 12 the Redis website experienced an unusual outage caused by an out‑of‑memory error from a Try‑Redis session leak on a low‑cost DigitalOcean droplet, prompting a rapid upgrade and configuration changes to restore service.
The article explains Redis's custom Simple Dynamic String (SDS) implementation, its memory layout, dynamic resizing rules, and performance benefits such as O(1) length retrieval, buffer‑overflow protection, and reduced allocation overhead through pre‑allocation and lazy reclamation.
This article examines common failures of Redis‑based distributed locks, explains the limitations of simple implementations, introduces the Redlock algorithm, and provides practical solutions for high‑concurrency, node failures, TTL overruns, and system clock drift.
This article explains how to implement automatic API idempotency in Spring Boot by using Redis for token storage, a custom @AutoIdempotent annotation, and a request interceptor, providing code examples and test steps to ensure duplicate requests are rejected.
This article details the design, installation, and modular integration of Flume, Kafka, Storm, Drools, and Redis to build a real‑time log analysis pipeline for ETL systems, discussing architecture, configuration, code examples, and practical considerations for scalability and fault tolerance.
This article details the architectural redesign, fault‑tolerance mechanisms, performance optimizations, and monitoring strategies employed in JD.com’s PC homepage, illustrating how backend technologies such as OpenResty, Lua, Redis, and NGINX are orchestrated to achieve high availability and sub‑30 ms page loads.
Learn how to ensure API idempotency in Spring Boot applications by leveraging Redis for token management, creating a custom @AutoIdempotent annotation, configuring interceptors, and handling token creation and validation to prevent duplicate submissions and maintain data integrity.
This article presents ten practical Redis best‑practice tips—from avoiding the costly KEYS * command to using hashes, setting appropriate expiration, choosing the right eviction policy, and ensuring high availability—helping developers optimize performance and reliability of their in‑memory data stores.
This article explores Redis, a high‑performance in‑memory key‑value store, detailing its core data types—String, List, Hash, Set, ZSet—the underlying structures such as SDS, quicklist, hashtable, and intset, and demonstrates practical usage patterns like caching, rate limiting, and inventory control.
This article explains the LRU caching principle, compares naive O(n) implementations, and shows how to achieve true O(1) insert and eviction using a HashMap combined with a doubly linked list, including practical Java code and an overview of Redis's approximate LRU algorithm.
Redis employs distinct memory reclamation mechanisms—expiration policies (timed, lazy, periodic) and eviction strategies triggered when maxmemory is reached—each with trade-offs in CPU and memory usage, and offers configurable policies such as allkeys‑lru, volatile‑ttl, and noeviction to manage cache data effectively.
This guide explains how to install Redis, configure it within a Spring Boot application, define custom Redis helper interfaces and implementations, and demonstrates testing and practical usage of caching annotations for efficient data retrieval.
This article explains the technical workflow of QR code login, covering the generation of UUIDs, QR images, server‑side Redis storage, mobile‑side token verification, long‑polling mechanisms, and the concrete implementations used by WeChat and Taobao, providing a complete reference for developers building similar authentication features.
Learn how to compile Redis from source and install it on an ARM-based system running Euler OS 2.8, covering environment setup, dependency building, configuration, service startup, and basic testing with redis-cli, demonstrating that the process mirrors standard installations.
This article walks through a complete performance‑testing setup for a VIP purchase callback API, detailing the request flow, distributed‑lock handling with Redis, parameter generation using AtomicInteger, Java implementation, and pitfalls to ensure accurate, high‑concurrency testing.
This article explains how to implement a Redis-based distributed lock using Jedis in Java, covering lock creation with SETNX, lock expiration, safe lock release via Lua scripts, and demonstrates the approach by simulating a 100,000-user concurrent order‑grabbing scenario.
This article explains common delayed‑queue scenarios, demonstrates how to implement a delay queue using Redis Zset with atomic Lua scripts, and shows how to deploy and use Beanstalkd—including Java client setup and sample producer/consumer code—while offering extensions and best‑practice tips.
This article explains the technical principles behind QR code login, detailing the client‑server interaction, UUID generation, Redis storage, long‑polling, and token handling, and illustrates the implementation with real‑world examples from Taobao and WeChat, including code snippets and flow diagrams.
This article explores the challenges of massive ticket‑buying spikes during holidays, explains the multi‑layer load‑balancing architecture, presents Go and Nginx configurations for weighted routing, demonstrates Redis‑based pre‑deduction of stock with Lua scripts, and shares stress‑test results showing thousands of requests per second on a single node.
This article explains the technical principles behind QR‑code login, detailing the end‑to‑end workflow between browsers, mobile apps and servers, and provides concrete implementations from Taobao and WeChat, including code snippets, polling mechanisms, Redis usage, and error handling.
This article explains how to build a simple two‑level caching solution in Java, covering generic cache interfaces, FIFO/LRU/LFU algorithms, implementing local Guava cache and distributed Redis cache, configuring Spring Boot, handling expiration, and providing a unified cache builder for seamless use.
This article provides an in‑depth overview of Redis, covering why it is used for performance and concurrency, its single‑threaded architecture, core data structures and their scenarios, expiration policies, memory eviction strategies, consistency challenges, and practical solutions for cache penetration, snowballing, and concurrent key updates.
This article explains the step‑by‑step process Redis follows to launch, from executing the redis‑server binary, initializing the server struct, loading configuration files, setting up data structures, restoring persistence, to entering the event loop.
During a performance test a query API failed on the second request because the Redis cache was written before asynchronous tasks finished, causing missing fields; the article explains the root cause, shows the original and fixed code, and details the debugging process.
This article explains why a Redis instance creates 16 default databases, how they function as simple namespaces rather than separate applications, how to configure their number, and why Redis clusters support only a single database.
This article details how JD.com’s engineering team designed, implemented, and optimized a user‑generated‑content platform that went from concept to production in 60 days, covering project background, system architecture, data storage with JimDB, messaging decoupling, asynchronous I/O, performance testing, and future improvements.
This article provides a comprehensive introduction to Redis, covering its key features, supported data structures, core commands, persistence mechanisms, replication, sentinel monitoring, sharding strategies, and transaction handling with practical code examples.
This guide provides a comprehensive walkthrough of Redis configuration options, covering memory unit notation, include templates, module loading, security settings, networking, persistence mechanisms, replication, clustering, Docker deployment, monitoring, and advanced memory and performance tuning.
This article aggregates over forty WeChat posts that cover Java interview topics ranging from Redis and hash structures to Spring lifecycle, multithreading, serialization, and database sharding, providing a valuable reference for developers preparing for technical interviews.
This article explains how to achieve interface idempotency in a Spring Boot application by generating a unique token for each request, storing it in Redis, validating the token via a custom annotation and interceptor, and provides complete code examples and testing guidance.
This guide explains the new Redis 6.0 cluster proxy feature, its purpose, and provides step‑by‑step instructions for installing, starting, and connecting to the proxy, including required GCC upgrades and example commands for a smooth setup.
The study traced severe Redis latency spikes in an 8‑core container to the Go runtime mistakenly reading the host’s CPU count, which created hundreds of threads and scheduler contention; limiting GOMAXPROCS to the container’s quota eliminated the jitter, while further gains were suggested by reducing HMGET calls, tuning GC, and upgrading Go.
This guide introduces Redis as a high‑performance key‑value store, covering its core data structures, advantages, persistence mechanisms, publish/subscribe model, transaction handling, and replication strategies with practical command examples.
This article walks through iQIYI's practical approach to database selection, covering key evaluation dimensions, a taxonomy of SQL/NoSQL and OLTP/OLAP workloads, detailed optimizations for MySQL, Redis, Couchbase and the internally built HiKV, as well as multi‑stage operational management and concrete selection recommendations.
This article analyzes the challenges of handling millions of simultaneous train‑ticket purchase requests, presents a multi‑layer load‑balancing architecture, introduces a pre‑deduction inventory strategy using Redis and local memory, and demonstrates a complete Go implementation with performance testing and key architectural insights.
This article examines the key challenges of flash‑sale (秒杀) systems—overselling, massive concurrency, URL exposure, and database coupling—and presents a complete backend design featuring dedicated databases, dynamic URLs, static pages, Redis clustering, Nginx proxy, rate‑limiting, token‑bucket control, asynchronous order queues, and service degradation strategies.
This article explains how to build a self‑healing dynamic proxy pool for 24/7 web crawling using Scrapy and Redis, covering requirements, design, implementation details, deployment steps, and a reusable Scrapy middleware example.
This article dissects the extreme‑load challenges of China’s 12306 train‑ticket service, explains its multi‑layer load‑balancing architecture, and provides a complete Go‑based spike‑system example that uses Nginx weighted round‑robin, Redis atomic stock deduction, and channel‑based locking to safely handle millions of concurrent purchase requests.
During holidays, millions of users scramble for train tickets, overwhelming the 12306 system; this article dissects its high‑concurrency architecture, explains load‑balancing layers, demonstrates Nginx weighted round‑robin configuration, and provides a Go‑based spike simulation with Redis stock management and performance results.
This article examines Suning's bargain‑group platform transformation, detailing its strategic shift to a platform model, high‑availability architecture, vertical and horizontal decomposition, data sharding, cache design, dual‑data‑center deployment, and link optimizations for handling massive concurrent traffic.
Redis creates 16 logical databases by default, a design inherited from its early architecture; this article explains the origin of that number, how to modify it via configuration, the proper way to view these databases as namespaces, and the limitations when using Redis in cluster mode.
The article describes how a hotel quoting team identified recurring Redis‑related outages, designed a comprehensive cache governance plan—including fast recovery, multi‑replica, manual downgrade, and parameter tuning—and executed a structured process that improved system reliability and operational readiness.
This article explains three Redis‑based techniques—using hash tables, bitsets, and the HyperLogLog probabilistic algorithm—to accurately count daily page views, detailing the required commands, implementation steps, advantages, and limitations for high‑traffic sites.
This article explains why caching is essential for Java distributed applications, introduces Redis and Redisson, and demonstrates how to implement distributed caches using Redisson Maps, Spring Cache integration, and the JCache API with practical code examples.
This article explains Flink's sliding window mechanism, shows how the WindowAssigner and WindowOperator work with code examples, analyzes the performance impact of fine‑grained sliding windows, and proposes a practical workaround using tumbling windows combined with external storage such as Redis for efficient PV/UV aggregation.
This article documents a hands‑on experiment that allocates a 50 GB Redis instance on a 64 GB dual‑node machine, explores NUMA behavior, demonstrates how memory affinity can trigger swap, and concludes with practical recommendations for Redis memory sizing and NUMA binding.
This article discusses iQIYI’s approach to database selection, covering evaluation criteria, the variety of databases used—including MySQL, TiDB, Redis, Couchbase, and the in‑house HiKV—along with detailed optimization, high‑availability, auditing, and operational management techniques for each system.
This article presents comprehensive guidelines for Alibaba Cloud Redis, covering readable and concise key naming, value design to avoid big keys, safe command usage, client connection pooling and circuit‑breaker patterns, appropriate eviction policies, and practical code examples for deleting large hashes, lists, sets, and sorted sets.
The article analyzes why a round‑robin load‑balancing approach caused severe response‑time spikes in Ctrip's compute‑intensive international ticket query engine and demonstrates how switching to a proactive pooling model using a Redis‑backed queue eliminated the spikes and reduced average latency by about 20%.
This article explains how to set Redis's maximum memory usage via configuration files or commands, describes the built‑in eviction strategies including noeviction, allkeys‑lru, volatile‑lru, allkeys‑random, volatile‑random, volatile‑ttl, and shows how to query and change these policies, while also covering LRU fundamentals, a Java LRU cache example, Redis's approximate LRU implementation, its 3.0 optimizations, and the newer LFU eviction algorithm.
This comprehensive guide explores Redis caching fundamentals, data structures, key‑search techniques, distributed lock implementation, asynchronous queues, persistence options (RDB, AOF, hybrid), pipeline usage, replication, Sentinel monitoring, and cluster sharding with consistent hashing to help developers build high‑performance, reliable systems.
This article explains how Redis implements its own string type using Simple Dynamic Strings (SDS), details the internal structure and dynamic expansion mechanism, and highlights the performance benefits such as O(1) length retrieval, buffer‑overflow protection, and reduced memory allocation overhead.
This article explains how to dramatically reduce Redis memory consumption—by up to 90%—through converting long string keys to integers, leveraging zipList‑encoded hashes, and distributing millions of key‑value pairs across many hash buckets while maintaining query performance.
The article explains what Redis cache avalanche, penetration, and breakdown are, illustrates real‑world incidents, and provides pre‑, during‑, and post‑incident solutions such as high‑availability setups, local caches with rate limiting, fallback mechanisms, and placeholder writes to prevent database overload.
This article explains how a distributed delayed‑execution component solves business scenarios that require timed actions, ensuring high availability and data consistency by leveraging Redis sorted sets and RabbitMQ dead‑letter queues, while providing a simple Java API and optional DB‑backed reliability.
An in‑depth guide covering Redis fundamentals, installation steps, daemon configuration, password setup, core commands for strings, lists, hashes, sets and sorted sets, internal encodings, and both RDB and AOF persistence mechanisms, complete with practical code examples and configuration snippets.
This article provides a comprehensive overview of Redis, explaining its core data structures, caching use cases, persistence mechanisms, high‑availability features like Sentinel and replication, clustering for horizontal scaling, and client‑side capabilities such as transactions, Lua scripting, pipelining, and distributed locks.
lmstfy is a stateless, Redis‑backed task‑queue service from Meitu that provides delayed execution, automatic retries, priority handling, expiration, and a RESTful HTTP API, while supporting horizontal scaling via namespace‑based token routing, rich Prometheus metrics, and future disk‑based storage extensions.
This article explains iQIYI's multi‑dimensional approach to database selection, details the practical use and optimization of MySQL, TiDB, Redis, Couchbase, and the internally built HiKV, and offers concrete recommendations for choosing the right database in different scenarios.
This article demonstrates how to create a custom @AccessLimit annotation, implement a Spring MVC interceptor that uses Redis to count requests, register the interceptor in a Spring Boot application, and apply the annotation to controller methods to achieve rate‑limiting functionality.
Redis Sentinel provides an automated high‑availability solution for Redis by monitoring master health, broadcasting SDOWN/ODOWN messages, electing a new master based on priority, offset and runid, and allowing clients to discover the current master via sentinel commands, all explained with configuration examples and diagrams.
This article analyzes a use‑case where each user must keep up to 10,000 historical IDs, compares two Redis‑based implementations—using a List and a String—by presenting code samples and benchmark results, and explains why understanding underlying data structures can dramatically improve performance.
This article details a complete backend solution for a high‑frequency like/unlike feature using Spring Cloud, Redis as a cache, MySQL for persistence, and Quartz to periodically transfer cached data to the database, covering installation, configuration, data modeling, service design, and scheduled tasks.
This article explains Redis cache avalanche, penetration, and breakdown, illustrates real interview scenarios, and provides practical strategies such as random expiration, Bloom filters, and high‑availability setups to help candidates answer these common interview questions confidently.
This article details the design principles, components, client implementation, data sharding, security mechanisms, high‑risk command blocking, configuration optimizations, and automated operational workflows of Qunar's Redis high‑availability cluster, including code modifications, deployment scripts, and platform‑based management for large‑scale production environments.
This article explains how to build a high‑traffic flash‑sale (秒杀) system by leveraging browser and CDN caching, read‑write split Redis for traffic interception, master‑slave Redis for atomic inventory deduction with Lua scripts, and Redis‑based message queues for asynchronous order processing.
This article details the design, requirements, architecture, and operational dashboard of Pepperbus, a unified bus system that standardizes asynchronous task handling for PHP, Java, and Go services at Huajiao, highlighting its storage plug‑in model, Redis‑based protocol, and monitoring capabilities.
This article explains the principles of Bloom filters, their false‑positive behavior, and demonstrates how to implement them using Google Guava in Java and Redis ReBloom via Docker, including code examples and a practical membership‑filtering use case.
This guide outlines practical Redis best practices, covering readable key naming with colons, keeping string values under 10 KB, setting expirations, avoiding O(n) commands, disabling risky commands, leveraging batch operations, and responsibly using the monitor command to maintain performance and stability.
This article provides comprehensive best‑practice guidelines for using Redis, covering data classification, key naming, size and connection limits, cache TTL, recommended client‑hash sharding, and a strict list of prohibited commands and operations to ensure performance, reliability, and maintainability.
