BestHub
Sign in
Tagged articles

Redis

3563 articles · Page 1 of 36
Code Farmer Manor Chronicle
Code Farmer Manor Chronicle
Oct 7, 2026 · Backend Development

Mastering High-Concurrency Caching: Penetration, Breakdown, Avalanche & Hot Keys

This article explains four classic high-concurrency caching problems—cache penetration, breakdown, avalanche, and hot keys—their root causes, differences, and practical solutions including empty-value caching, Bloom filters, mutex locks, logical expiration, TTL jitter, multi-level caching, and cache-database consistency patterns.

Bloom FilterCache AsideCache Avalanche
0 likes · 12 min read
Mastering High-Concurrency Caching: Penetration, Breakdown, Avalanche & Hot Keys
ITPUB
ITPUB
Oct 7, 2026 · Backend Development

Rails 8 Drops Redis: How PostgreSQL's SKIP LOCKED Powers SolidQueue

Rails 8 replaces Redis with database-backed SolidQueue, SolidCache, and SolidCable, leveraging PostgreSQL's SKIP LOCKED for efficient task queues and arguing that most applications overpay a hidden 'middleware tax' for specialized infrastructure they don't actually need.

PostgreSQLRails 8Redis
0 likes · 14 min read
Rails 8 Drops Redis: How PostgreSQL's SKIP LOCKED Powers SolidQueue
Architect's Guide
Architect's Guide
Oct 6, 2026 · Databases

Illustrated Redis: Architecture, Replication & Persistence Internals

This article provides a comprehensive visual guide to Redis architecture, covering single-instance deployment, high-availability setups with Sentinel, Redis Cluster sharding with hash slots, replication mechanics using replication IDs and offsets, and persistence models including RDB snapshots, AOF logging, and the fork/copy-on-write mechanism.

ClusterCopy-on-WritePersistence
0 likes · 20 min read
Illustrated Redis: Architecture, Replication & Persistence Internals
IT Services Circle
IT Services Circle
Oct 5, 2026 · Databases

Redis Distributed Locks: 7 Critical Pitfalls and How to Avoid Them

This article details seven common pitfalls in Redis distributed locking, covering atomic acquisition, ownership verification, lease expiration, watchdog limitations, replication risks, Redlock assumptions, and the need for fencing tokens, with code examples and comparisons to ZooKeeper and etcd.

Martin KleppmannRedisRedisson
0 likes · 32 min read
Redis Distributed Locks: 7 Critical Pitfalls and How to Avoid Them
liandk
liandk
Oct 4, 2026 · Backend Development

High-Concurrency Flash Sale Architecture: Layered Rate Limiting, Overselling Prevention & Cache Protection

This article details a production-grade five-layer architecture for high-concurrency flash sale systems, covering traffic shaping via message queues, multi-level rate limiting, three-tier overselling prevention using Redis atomic operations and database optimistic locking, and solutions for cache penetration, breakdown, and avalanche, plus nine common failure scenarios and a troubleshooting SOP.

High ConcurrencyMessage QueueRedis
0 likes · 17 min read
High-Concurrency Flash Sale Architecture: Layered Rate Limiting, Overselling Prevention & Cache Protection
Java Captain
Java Captain
Sep 30, 2026 · Interview Experience

WXG First-Round Interview: 60 Questions from Algorithms to Agent Design

A shared WXG first-round interview experience lists 60 questions covering self-introduction, algorithms (IP-to-uint64, linked-list folding, uniform sampling), system design, AI tools, large-model hallucinations, RAG, vector search, collaborative filtering, 12306 ticketing architecture, Redis internals, MySQL B+ trees, concurrency locks, and design patterns.

AlgorithmsB+ TreeDesign Patterns
0 likes · 7 min read
WXG First-Round Interview: 60 Questions from Algorithms to Agent Design
dbaplus Community
dbaplus Community
Sep 27, 2026 · Fundamentals

Why the Creators of Linux, Python, Redis, Nginx & SQLite Are True Geniuses

The article argues that creators of foundational software like Linux, Python, Redis, Nginx, and SQLite are true geniuses due to their exceptional abstraction skills and system-level boundary control, illustrated by real-world cases where their minimal, convergent designs outperform modern complex solutions, and warns that over-reliance on AI tools erodes deep system understanding essential for solving hard production issues.

AI-assisted codingLinuxNginx
0 likes · 14 min read
Why the Creators of Linux, Python, Redis, Nginx & SQLite Are True Geniuses
Golang Shines
Golang Shines
Sep 26, 2026 · Operations

Complete Disk I/O Alert Troubleshooting: From Alert to Root Cause with 5 Real Cases

This article details a complete disk I/O alert investigation in production, covering core concepts like IOPS vs throughput, iostat/iotop analysis, and five real-world cases including MySQL missing indexes, log misconfiguration, backup conflicts, Redis persistence, and filesystem mount options, providing a reusable troubleshooting methodology.

MySQLOperationsPrometheus
0 likes · 65 min read
Complete Disk I/O Alert Troubleshooting: From Alert to Root Cause with 5 Real Cases
Cloud Architecture
Cloud Architecture
Sep 24, 2026 · Backend Development

Scaling Spring Boot Sign-In to 100M Users: Distributed Architecture Evolution & Production Hardening

This article details the evolution of a Spring Boot daily sign-in system from 10K to 100M users, covering Redis bitmap sharding, Lua atomic operations, command outbox pattern, Kafka async reward processing, idempotency guarantees, fault tolerance strategies, and production-grade observability with real incident postmortems.

BitmapCommand OutboxKafka
0 likes · 36 min read
Scaling Spring Boot Sign-In to 100M Users: Distributed Architecture Evolution & Production Hardening
liandk
liandk
Sep 24, 2026 · Backend Development

Redis Production Fault Troubleshooting: 8 Critical Issues & Solutions

This article details eight high-frequency Redis production faults—cache penetration, breakdown, avalanche, big keys, hot keys, connection exhaustion, memory OOM, and consistency issues—providing symptoms, root causes, troubleshooting commands, solutions, and a universal SOP for rapid diagnosis and resolution.

Cache AvalancheCache BreakdownCache Penetration
0 likes · 14 min read
Redis Production Fault Troubleshooting: 8 Critical Issues & Solutions
Xiaolin Talks Programming
Xiaolin Talks Programming
Sep 23, 2026 · Backend Development

Spring Boot QR Code Login: State Machines, SSE Push, and Replay Protection for Production

This article details a production-ready QR code login implementation using Spring Boot, covering state machine design with Redis and Lua for atomic transitions, SSE for low-latency status push with polling fallback, HMAC-SHA256 with nonce for replay protection, and Redis Pub/Sub for cross-instance consistency in clustered deployments.

Lua ScriptsQR Code LoginRedis
0 likes · 28 min read
Spring Boot QR Code Login: State Machines, SSE Push, and Replay Protection for Production
LuTiao Programming
LuTiao Programming
Sep 22, 2026 · Backend Development

Beyond Distributed Locks: Three-Layer Idempotency for Spring Boot Order APIs

The article demonstrates why distributed locks alone fail to guarantee idempotency in Spring Boot order APIs, and presents a three-layer solution combining Idempotency-Key with request fingerprinting, Redis SET NX for fast duplicate interception, and a database unique constraint as the ultimate safeguard against duplicate orders even after crashes or Redis failures.

API DesignMySQLOrder Service
0 likes · 25 min read
Beyond Distributed Locks: Three-Layer Idempotency for Spring Boot Order APIs
LuTiao Programming
LuTiao Programming
Sep 21, 2026 · Backend Development

Distributed Rate Limiting with Redis + Lua: Surviving API Floods in Spring Boot

After an external system hammered a Spring Boot search endpoint causing database connection exhaustion, the author builds a distributed fixed-window rate limiter using Redis and Lua for atomicity, wraps it with an annotation-driven AOP aspect supporting user, IP, API key, and global dimensions, returns proper HTTP 429 with Retry-After, discusses fixed-window limitations versus token bucket and sliding window, and covers fail-open/fail-closed strategies for Redis outages plus monitoring metrics.

AOPFail-OpenFixed Window
0 likes · 17 min read
Distributed Rate Limiting with Redis + Lua: Surviving API Floods in Spring Boot
Java Captain
Java Captain
Sep 16, 2026 · Backend Development

Spring Boot Email Integration: Build Verification Code System with Redis & Thymeleaf

This tutorial walks through email protocols, third-party SMTP setup for Feishu and QQ, Spring Boot mail starter configuration, core JavaMailSender/MimeMessage/MimeMessageHelper relationships, and a complete email verification code implementation using Redis for storage and Thymeleaf for HTML templates.

Email VerificationIMAPJavaMailSender
0 likes · 14 min read
Spring Boot Email Integration: Build Verification Code System with Redis & Thymeleaf
Architect's Guide
Architect's Guide
Sep 16, 2026 · Backend Development

Implementing Cross-System Single Sign-On with CAS: A Practical Guide

This article explains how to implement Single Sign-On (SSO) using CAS to unify authentication across multiple company systems, covering session mechanics, cluster session sharing with Redis, and providing complete Spring Boot code examples for both the CAS server and client applications.

AuthenticationCASRedis
0 likes · 16 min read
Implementing Cross-System Single Sign-On with CAS: A Practical Guide
Xiaolin Talks Programming
Xiaolin Talks Programming
Sep 9, 2026 · Backend Development

Spring Boot Sa-Token Integration: High-Availability Auth with Dynamic Permissions & Replay Protection

This article details integrating Sa-Token 1.37.0 with Spring Boot 2.7.x and Redis 6.x for authentication, covering dependency setup, configuration, login implementation, dynamic permission via StpInterface, API replay protection using nonce/timestamp/signature, cluster deployment, comparison with Spring Security+JWT, and production pitfalls.

AuthenticationCluster DeploymentDynamic Permissions
0 likes · 22 min read
Spring Boot Sa-Token Integration: High-Availability Auth with Dynamic Permissions & Replay Protection
Java Tech Enthusiast
Java Tech Enthusiast
Sep 6, 2026 · Backend Development

Why Sa-Token Is Winning Over Spring Security: A Deep Dive into Java's Rising Auth Framework

This article analyzes why Sa-Token has surpassed 46K GitHub stars by comparing its Core-Plugin-Adapter architecture, zero-config startup, and one-line authentication API against Spring Security's steep learning curve, demonstrating how it reduces permission system implementation from weeks to days.

Core-Plugin-AdapterDistributed SessionJWT
0 likes · 18 min read
Why Sa-Token Is Winning Over Spring Security: A Deep Dive into Java's Rising Auth Framework
ITPUB
ITPUB
Sep 6, 2026 · Backend Development

How WeChat Resets 1 Billion Step Counts at Midnight Without Crashing

WeChat avoids server crashes during midnight step-count resets for 1 billion users by using logical time-based versioning instead of physical updates, a custom PaxosStore for atomic increments, delayed double-write buffers for clock skew, Redis ZSet sharding for rankings, and asynchronous cold-data archival during low-traffic hours.

High ConcurrencyPaxosStoreRedis
0 likes · 18 min read
How WeChat Resets 1 Billion Step Counts at Midnight Without Crashing
MaGe Linux Operations
MaGe Linux Operations
Sep 5, 2026 · Operations

Troubleshooting High Redis Client Connections: A Step-by-Step Guide to Identification and Optimization

This comprehensive guide details a systematic approach to diagnosing and resolving high Redis client connection counts, covering connection models, configuration tuning, CLI analysis commands, application-level connection pool fixes, temporary mitigation tactics, and long-term monitoring best practices with real-world case examples.

CLIENT LISTJedisMonitoring
0 likes · 35 min read
Troubleshooting High Redis Client Connections: A Step-by-Step Guide to Identification and Optimization
Java Tech Enthusiast
Java Tech Enthusiast
Sep 2, 2026 · Backend Development

Recreating WeChat‑style Message Recall in Spring Boot: Why Deleting Isn’t Enough

The article walks through a complete Spring Boot implementation of WeChat‑like message recall, explaining why a simple DELETE is insufficient and detailing how to use a status flag, conditional UPDATE, WebSocket, Redis/MQ, and multi‑device session management to synchronize recall across all clients, even under concurrency and offline scenarios.

MQMySQLRedis
0 likes · 11 min read
Recreating WeChat‑style Message Recall in Spring Boot: Why Deleting Isn’t Enough
IT Learning Made Simple
IT Learning Made Simple
Sep 1, 2026 · Fundamentals

Why LRU Evicts the Least Recently Used Page First

The article explains the LRU (Least Recently Used) page‑replacement algorithm, its basis in the locality principle, hit‑rate example, various exact and approximate implementations—including counter, stack, linked‑list, Clock, Aging and Working‑Set methods—its hardware requirements, pros and cons, and practical uses such as a Python cache and Redis eviction policies.

CachingLRUPython
0 likes · 10 min read
Why LRU Evicts the Least Recently Used Page First
Alibaba Cloud Observability
Alibaba Cloud Observability
Sep 1, 2026 · Cloud Native

Cross-Layer Root Cause Analysis: How STAROps & Yaochi Agent Trace Alerts to Missing Indexes & Blocking Lua Scripts

The article demonstrates how STAROps' full-stack correlation combined with Yaochi Agent's deep database diagnosis enables cross-layer root cause analysis across three real incidents: an RDS missing index, a Redis Lua script blocking the single thread, and an EVAL command causing CPU saturation, showing command-level diagnostic precision.

EVAL commandLua scriptRDS
0 likes · 14 min read
Cross-Layer Root Cause Analysis: How STAROps & Yaochi Agent Trace Alerts to Missing Indexes & Blocking Lua Scripts
LuTiao Programming
LuTiao Programming
Aug 30, 2026 · Databases

I Finally Deleted the Java Code That Reads the Whole Redis Object to Update One Field

The article explains how the old pattern of GET‑ing an entire JSON string from Redis, deserializing it in Java, modifying a single field and writing it back is inefficient and error‑prone, and shows how Spring Data Redis 4.2’s RedisJsonTemplate lets you update or read individual JSON paths directly, reducing code, network traffic and race‑condition risks.

JSONJavaRedis
0 likes · 15 min read
I Finally Deleted the Java Code That Reads the Whole Redis Object to Update One Field
Architect's Tech Stack
Architect's Tech Stack
Aug 29, 2026 · Artificial Intelligence

Redis 8's AI Overhaul: Vector Search, Vector Sets, Semantic Cache & Iris Context Engine

This article analyzes Redis 8's new AI capabilities including vector search with HNSW and int8 quantization, the native Vector Sets data type, LangCache semantic caching for LLM cost reduction, and the Iris real-time context engine for agent memory, with code examples and a comparison of when to use each feature.

AI InfrastructureHNSWRedis
0 likes · 9 min read
Redis 8's AI Overhaul: Vector Search, Vector Sets, Semantic Cache & Iris Context Engine
Yumin Fish Harvest
Yumin Fish Harvest
Aug 29, 2026 · Backend Development

CosId Distributed ID Generation: Snowflake & Segment Modes Explained

This article explores CosId's two ID generation modes—local computation (Snowflake) and segment allocation (SegmentId, SegmentChainId)—with detailed configuration for JDBC, Redis, ZooKeeper, MongoDB, and Proxy backends, plus Spring Boot, MyBatis, and ShardingSphere integration examples.

CosIdJDBCRedis
0 likes · 34 min read
CosId Distributed ID Generation: Snowflake & Segment Modes Explained
Code Ape Tech Column
Code Ape Tech Column
Aug 28, 2026 · Databases

Redis Transforms into AI Data Infrastructure: Vector Search, Vector Sets, Semantic Cache & Agent Memory

This article details Redis's evolution into a comprehensive AI data infrastructure, covering its four core capabilities—vector search with hybrid queries, native Vector Sets data type, LangCache semantic caching for 70% LLM cost reduction, and Redis Iris context engine for AI agent memory—with technical implementations, performance benchmarks, and use-case recommendations.

AI agent memoryHNSWJava
0 likes · 16 min read
Redis Transforms into AI Data Infrastructure: Vector Search, Vector Sets, Semantic Cache & Agent Memory
Programmer XiaoFu
Programmer XiaoFu
Aug 28, 2026 · Backend Development

Why Spring Cloud Gateway Rate Limiting Fails to Protect Downstream Services

The article analyzes five reasons why Spring Cloud Gateway's Redis-based token bucket rate limiting fails to protect downstream services during traffic bursts, including QPS vs. concurrency confusion, burstCapacity spikes, multi-route quota multiplication, KeyResolver fallback flaws, and Redis bottleneck fail-open behavior, then recommends tightening burst limits, adding downstream concurrency isolation with Sentinel/Resilience4j, and hardening KeyResolver configuration.

Burst TrafficRedisResilience4j
0 likes · 13 min read
Why Spring Cloud Gateway Rate Limiting Fails to Protect Downstream Services
Cloud Architecture
Cloud Architecture
Aug 27, 2026 · Backend Development

Reliable Delivery for Billion-Scale LongConn Gateways: Tackling ACK Storms

The article explains why a successful Netty write does not guarantee message delivery, and presents a production‑grade solution for billion‑scale long‑connection gateways that combines application‑level ACKs, timeout‑driven retries, offline compensation, state‑machine design, back‑pressure handling, and observability to prevent ACK storms and retry avalanches.

ACK StormKafkaMessage Delivery
0 likes · 29 min read
Reliable Delivery for Billion-Scale LongConn Gateways: Tackling ACK Storms
Su San Talks Tech
Su San Talks Tech
Aug 27, 2026 · Artificial Intelligence

How Redis Becomes the Real‑Time Data Backbone for AI

Redis has evolved from a pure cache middleware into a full‑stack AI data infrastructure, offering vector search, native vector sets, semantic caching, and an AI Agent context engine, with sub‑millisecond latency, high throughput, and detailed performance benchmarks that illustrate its strengths and trade‑offs.

AIJavaRedis
0 likes · 15 min read
How Redis Becomes the Real‑Time Data Backbone for AI
DeWu Technology
DeWu Technology
Aug 26, 2026 · Artificial Intelligence

Enterprise MultiAgent Memory: Short-Term Context & Four-Layer Architecture

The article details a four-layer memory system for enterprise MultiAgent platforms, covering short-term memory loading/writing with Redis/MySQL, long-term memory retrieval via MemOS semantic search, token budget allocation, LLM-based memory judgment, deduplication, conflict resolution, and write-before-delete strategies.

Conflict ResolutionLLM JudgmentMemOS
0 likes · 31 min read
Enterprise MultiAgent Memory: Short-Term Context & Four-Layer Architecture
Programmer1970
Programmer1970
Aug 23, 2026 · Backend Development

Custom Spring Cloud Gateway Filters for Rate Limiting, Circuit Breaking & Gray Release

This article details the development of custom Spring Cloud Gateway plugins for rate limiting, circuit breaking, and gray release to overcome Sentinel's production limitations, covering architecture design, Redis-based rule storage with pub/sub, token bucket and sliding window algorithms, circuit breaker state machines, tag-based canary routing, and production lessons learned with performance benchmarks.

Circuit BreakingRedisSpring Cloud Gateway
0 likes · 20 min read
Custom Spring Cloud Gateway Filters for Rate Limiting, Circuit Breaking & Gray Release
Code Farming
Code Farming
Aug 21, 2026 · Databases

How to Cut Redis Cluster Failover to Under 10 Seconds

The article breaks down Redis‑Cluster failover into detection, election, failover, and client perception stages, explains the timing bottlenecks of each, and provides concrete server‑side and Lettuce client configurations that shrink end‑to‑end recovery to under ten seconds.

LettuceRedisRedis Cluster
0 likes · 7 min read
How to Cut Redis Cluster Failover to Under 10 Seconds
The Dominant Programmer
The Dominant Programmer
Aug 19, 2026 · Artificial Intelligence

Persisting Spring AI Alibaba Memory to Redis: A Hands‑On Guide

This guide walks through configuring Spring AI Alibaba 1.1.2.0 to persist an agent's short‑term memory in Redis, covering environment setup, core concepts like Checkpointer and StateSerializer, step‑by‑step Maven project creation, code snippets, common pitfalls, and verification of multi‑turn conversation state across sessions.

AgentJavaRedis
0 likes · 17 min read
Persisting Spring AI Alibaba Memory to Redis: A Hands‑On Guide
Coder Trainee
Coder Trainee
Aug 19, 2026 · Backend Development

The “Ghost” Distributed Lock Issue: 3‑Day Debugging of Lock Failure

The article walks through a real production incident where a Redis‑based distributed lock silently failed, causing duplicate point awards, and details the step‑by‑step investigation, root‑cause analysis of transaction‑lock ordering, and three concrete remediation strategies.

Pessimistic LockRedisRedisson
0 likes · 9 min read
The “Ghost” Distributed Lock Issue: 3‑Day Debugging of Lock Failure
Mike Chen Rui
Mike Chen Rui
Aug 19, 2026 · Backend Development

What TPS Levels Define a High‑Performance E‑Commerce Flash Sale?

The article explains how flash‑sale systems differ from regular e‑commerce, outlines characteristic traffic spikes, and defines TPS ranges—100‑1,000, 1,000‑5,000, 5,000‑10,000, and 10,000‑50,000—that indicate low, medium, mature, and ultra‑high concurrency, while noting the architectural techniques needed to sustain tens of thousands of requests.

High ConcurrencyMessage QueueRedis
0 likes · 4 min read
What TPS Levels Define a High‑Performance E‑Commerce Flash Sale?
YiSu Grain
YiSu Grain
Aug 19, 2026 · Databases

Optimizing Slow Queries, Sharding and Cache Consistency for Appointment System

This article walks through a comprehensive case study of a provincial medical appointment platform, diagnosing slow‑query bottlenecks, proposing patient‑id + create_time composite indexes, designing read‑write separation with replication, selecting patient_id for horizontal sharding, and implementing cache‑aside strategies to ensure consistency while handling cache avalanche, penetration and thundering‑herd scenarios.

MySQLRediscache consistency
0 likes · 30 min read
Optimizing Slow Queries, Sharding and Cache Consistency for Appointment System
Architect's Guide
Architect's Guide
Aug 19, 2026 · Backend Development

How to Implement Redis Cache Preheating in Spring

This article explains the concept of cache preheating, provides an abstract cache class, a Spring context utility, and a CommandLineRunner implementation that automatically loads hot data into Redis at startup, demonstrating the approach with a news‑cache example and related controller code.

AbstractCacheCache PreheatingCommandLineRunner
0 likes · 5 min read
How to Implement Redis Cache Preheating in Spring
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 19, 2026 · Backend Development

Building Distributed Rate Limiting with Spring Boot, Redis & Lua: Sliding Window, Token Bucket & Flash Sale Defense

This article details a production-ready distributed rate limiting system using Spring Boot AOP, Redis Sorted Sets, and atomic Lua scripts, covering sliding window and token bucket algorithms, multi-dimensional flash sale protection, and benchmark results showing 100% accuracy with minimal latency overhead.

AOPLuaRedis
0 likes · 18 min read
Building Distributed Rate Limiting with Spring Boot, Redis & Lua: Sliding Window, Token Bucket & Flash Sale Defense
Cloud Architecture
Cloud Architecture
Aug 18, 2026 · Backend Development

Scalable Enterprise Real‑Time Push with Spring Boot, WebFlux, Kafka & Redis

This guide walks through why traditional polling or WebSocket solutions quickly break at scale, explains the Server‑Sent Events protocol, and presents a production‑grade architecture that combines Spring Boot 3, WebFlux, Kafka, Redis, and Kubernetes to deliver reliable, ordered, and observable one‑way push notifications for millions of concurrent users.

KafkaRedisSSE
0 likes · 43 min read
Scalable Enterprise Real‑Time Push with Spring Boot, WebFlux, Kafka & Redis
Architect Chen
Architect Chen
Aug 18, 2026 · Databases

Why Does Redis Memory Suddenly Spike? A Large‑Scale Troubleshooting Guide

The article presents a four‑layer method for diagnosing sudden Redis memory growth, covering recent releases or configuration changes, key monitoring metrics, sampled key analysis, and emergency mitigation steps, with concrete metric definitions and practical examples.

Key AnalysisPerformance MonitoringRedis
0 likes · 6 min read
Why Does Redis Memory Suddenly Spike? A Large‑Scale Troubleshooting Guide
Ray's Galactic Tech
Ray's Galactic Tech
Aug 17, 2026 · Backend Development

From DB Row Locks to Redis + Lua: Evolving Flash‑Sale Inventory Deduction

The article walks through the evolution of a flash‑sale inventory‑deduction system, starting with simple database row‑locking SQL, exposing its scalability limits, and progressively adding transaction trimming, Redis pre‑deduction, Lua atomic scripts, async pipelines, idempotency, reconciliation and robust engineering practices to handle extreme concurrency.

AsyncProcessingHighConcurrencyInventoryDeduction
0 likes · 40 min read
From DB Row Locks to Redis + Lua: Evolving Flash‑Sale Inventory Deduction
Java Tech Workshop
Java Tech Workshop
Aug 17, 2026 · Backend Development

How to Keep Redis and MySQL Consistent? Update DB First or Delete Cache First?

This article analyzes why cache and database can become inconsistent, compares four basic cache‑update patterns, explains the delayed double‑delete technique, shows how to use MQ for retrying cache deletions, and evaluates Canal binlog subscription as a zero‑intrusion solution for strong eventual consistency.

Cache AsideCanal BinlogDelayed Double Delete
0 likes · 28 min read
How to Keep Redis and MySQL Consistent? Update DB First or Delete Cache First?
Cloud Architecture
Cloud Architecture
Aug 16, 2026 · Backend Development

How to Build a 100k QPS Seckill System with Spring Boot, Redis, and Lua

This article provides a production‑grade, step‑by‑step engineering guide for designing a high‑concurrency seckill (flash‑sale) system that can sustain 100,000 QPS using Spring Boot, Redis with Lua scripts, asynchronous messaging, and comprehensive fault‑tolerance, monitoring, and scalability techniques.

High ConcurrencyLuaRedis
0 likes · 40 min read
How to Build a 100k QPS Seckill System with Spring Boot, Redis, and Lua
Architect's Guide
Architect's Guide
Aug 16, 2026 · Backend Development

How Architects Can Achieve Unified Login Across Company Products

The article explains why traditional session mechanisms break in clustered and multi‑service environments, compares session replication and centralized storage, introduces CAS‑based single sign‑on with ticket flow, contrasts it with OAuth2, and provides a complete Spring‑Boot demo with Redis‑backed session handling.

AuthenticationCASJava
0 likes · 15 min read
How Architects Can Achieve Unified Login Across Company Products
dbaplus Community
dbaplus Community
Aug 13, 2026 · Databases

Why Redis Cluster Limits You to DB 0 (and How to Work Around It)

Redis Cluster enforces a single database (DB 0) because its slot‑based sharding model relies on a global 16,384‑slot map, and supporting multiple databases would break slot consistency, migration, and scalability, so developers must use key prefixes, separate instances, or multiple clusters to achieve logical isolation.

DB0Distributed ConsistencyKey Prefix
0 likes · 7 min read
Why Redis Cluster Limits You to DB 0 (and How to Work Around It)
Code Farming
Code Farming
Aug 13, 2026 · Databases

Redis vs MySQL for Shopping Carts: Why I Chose the Option That Can Lose Data

The article explains that a shopping cart can tolerate loss of recent writes but not accumulated items, outlines the data model with seven fields and a unique key, compares client‑side storage options, details merge strategies for guest and logged‑in carts, and evaluates Redis, MySQL, and hybrid solutions with concrete trade‑offs.

MySQLRedisShopping Cart
0 likes · 13 min read
Redis vs MySQL for Shopping Carts: Why I Chose the Option That Can Lose Data
Cloud Architecture
Cloud Architecture
Aug 12, 2026 · Databases

How Redis Cluster’s Decentralized Design Powers Billion‑Scale Traffic

When a single Redis instance can no longer hold the data volume or write load of e‑commerce workloads, the traditional master‑slave with Sentinel model reaches its limits, and Redis Cluster—by sharding data across 16,384 slots, using gossip‑based topology, and removing a central control plane—delivers horizontal scaling and fault‑tolerance for billions of requests, provided key design, hash tags, hot‑key mitigation, and client routing are applied.

ClusterRediscache
0 likes · 32 min read
How Redis Cluster’s Decentralized Design Powers Billion‑Scale Traffic
SpringMeng
SpringMeng
Aug 12, 2026 · Databases

RedisInsight: The Official High‑Performance GUI for Redis

This article introduces RedisInsight, the official visual management tool for Redis, outlines its key features, provides step‑by‑step installation on Linux and Kubernetes, and demonstrates basic usage for monitoring, querying, and memory analysis through the GUI.

GUIKubernetesLinux
0 likes · 7 min read
RedisInsight: The Official High‑Performance GUI for Redis
samdeepthink
samdeepthink
Aug 12, 2026 · Backend Development

Designing an Enterprise‑Level CAS SSO Architecture: A Practical Blueprint

This article presents a detailed technical blueprint for building an enterprise‑grade single sign‑on system that combines Apereo CAS, OAuth2, and JWT across four microservices, covering service responsibilities, data models, API contracts, deployment trade‑offs, and operational safeguards.

CASJWTOAuth2
0 likes · 26 min read
Designing an Enterprise‑Level CAS SSO Architecture: A Practical Blueprint
Cloud Architecture
Cloud Architecture
Aug 11, 2026 · Databases

Redis Sentinel Deep Dive: Leader Election, Failover Mechanics, and Production Best Practices

This article dissects Redis Sentinel’s high‑availability workflow—from failure detection, SDOWN/ODOWN states, and quorum logic to leader election, replica promotion, and configuration propagation—while illustrating each step with a real‑world e‑commerce cache case, detailed configuration snippets, Kubernetes deployment patterns, Spring Boot integration, and operational playbooks for observability and fault‑injection testing.

KubernetesRedisSentinel
0 likes · 48 min read
Redis Sentinel Deep Dive: Leader Election, Failover Mechanics, and Production Best Practices
Java Architect Handbook
Java Architect Handbook
Aug 11, 2026 · Backend Development

Why Interviewers Mock Storing Tokens in Redis—and How to Answer

The article explains what JWT is, why its stateless design can cause problems, compares pure JWT, JWT with a blacklist, and storing tokens in Redis (whitelist), and provides a step‑by‑step guide on how to discuss these options convincingly in a Java interview.

AuthenticationBackendBlacklisting
0 likes · 11 min read
Why Interviewers Mock Storing Tokens in Redis—and How to Answer
Cloud Architecture
Cloud Architecture
Aug 10, 2026 · Databases

Master‑Slave Replication in Redis: Core Mechanics Explained and Production Deployment

This article provides a comprehensive, production‑focused analysis of Redis master‑slave replication, covering its internal state machine, full and partial sync processes, configuration pitfalls, performance bottlenecks, consistency trade‑offs, and practical deployment patterns with Docker, Kubernetes, and Spring Boot.

Docker ComposeKubernetesRedis
0 likes · 38 min read
Master‑Slave Replication in Redis: Core Mechanics Explained and Production Deployment
Woodpecker Software Testing
Woodpecker Software Testing
Aug 10, 2026 · Operations

Cache Strategy Testing: Cost‑Benefit Analysis for Test Engineers

With modern high‑concurrency, low‑latency systems relying on multi‑layer caches like Redis, CDN, and Guava, this article presents a risk‑based, cost‑effective testing framework that quantifies hidden testing costs, prioritizes cache types by impact, and recommends high‑leverage techniques such as protocol validation, expiration edge testing, and production traffic replay.

Rediscache testingchaos engineering
0 likes · 8 min read
Cache Strategy Testing: Cost‑Benefit Analysis for Test Engineers
SpringMeng
SpringMeng
Aug 10, 2026 · Databases

Exploring RedisInsight’s New Web UI: Stunning Visuals and Powerful Features

This article walks through RedisInsight’s newly released web version, showing how to deploy it with Docker, highlighting its intuitive UI for browsing and editing various Redis data types, built‑in workbench, slow‑log and memory analysis, multi‑model support, theme switching, and built‑in tutorials.

Database VisualizationDockerRedis
0 likes · 5 min read
Exploring RedisInsight’s New Web UI: Stunning Visuals and Powerful Features
Java Tech Workshop
Java Tech Workshop
Aug 10, 2026 · Backend Development

SpringBoot Backend Anti‑Duplicate Submission: Stop “Hand‑Shake” Clicks with Redis‑AOP

This article explains why frontend debouncing cannot fully prevent duplicate form submissions, compares common backend anti‑duplicate strategies, and provides a step‑by‑step guide to implementing a robust, annotation‑driven solution in SpringBoot using Redis distributed locks, AOP, and custom exception handling.

AOPBackendDuplicateSubmission
0 likes · 16 min read
SpringBoot Backend Anti‑Duplicate Submission: Stop “Hand‑Shake” Clicks with Redis‑AOP
Lobster Programming
Lobster Programming
Aug 10, 2026 · Backend Development

Designing Efficient Read/Unread Tracking for One-on-One and Group Chats

The article examines how to implement read/unread status for single and group chats at scale, comparing a simple last‑read‑ID approach for one‑on‑one conversations with database, Redis hash, and bitmap‑watermark solutions for groups, and discusses their performance and memory trade‑offs.

BackendBitmapMySQL
0 likes · 7 min read
Designing Efficient Read/Unread Tracking for One-on-One and Group Chats
Cloud Architecture
Cloud Architecture
Aug 9, 2026 · Databases

Redis Persistence Deep Dive: From a Major P0 Outage to RDB+AOF Hybrid Implementation

The article analyses a real‑world P0 outage caused by treating Redis as a simple cache, explains why persistence is the decisive factor when Redis stores session, inventory or lock data, and provides a step‑by‑step guide to RDB, AOF and hybrid persistence, configuration, monitoring, recovery and best‑practice recommendations.

AOFHybrid PersistencePersistence
0 likes · 33 min read
Redis Persistence Deep Dive: From a Major P0 Outage to RDB+AOF Hybrid Implementation
IT Services Circle
IT Services Circle
Aug 9, 2026 · Backend Development

How to Detect a 30‑Day Continuous Sign‑In for 1 B Users with 1 GB Memory

The article breaks down a large‑scale interview question, showing why storing each sign‑in as a database row is infeasible, how a bitmap compresses a year of data to 46 bytes per user, the pitfalls of BITCOUNT, the importance of key dimension design, and the exact Redis commands and local‑scan algorithms—including a five‑step bit‑wise trick—to reliably determine a 30‑day continuous sign‑in.

BitmapKey DesignRedis
0 likes · 9 min read
How to Detect a 30‑Day Continuous Sign‑In for 1 B Users with 1 GB Memory
Architect's Guide
Architect's Guide
Aug 7, 2026 · Backend Development

A Clear Diagram of the User Login Verification Process

This article walks through a complete user login flow—including client verification, token generation, expiration policies, gateway validation, logout handling, anonymous access, rate‑limiting via authorized tokens, regex path checks, and blacklist management—illustrated with diagrams and Spring‑Redis code examples.

AuthenticationRedisSpring
0 likes · 9 min read
A Clear Diagram of the User Login Verification Process
Xike
Xike
Aug 7, 2026 · Databases

Embedding Sharding Genes in Business IDs for Direct Routing in Sharded Databases

By embedding a shard identifier (“gene”) into the low bits of a business ID generated via Redis INCR or similar sequencers, the article shows how to achieve direct table routing without broadcast queries or extra mapping tables, detailing the algorithm, implementation, integration with Snowflake and Leaf, and common pitfalls.

JavaLeafRedis
0 likes · 11 min read
Embedding Sharding Genes in Business IDs for Direct Routing in Sharded Databases
Ray's Galactic Tech
Ray's Galactic Tech
Aug 6, 2026 · Databases

Taming Message Storms: Redis 7.x Engineering Practices for Enterprise Live‑Streaming Platforms

This article dissects why a simple Redis upgrade is insufficient for large‑scale live streaming, then walks through how Redis 7’s Sharded Pub/Sub, Function, and ACL v2 features together eliminate broadcast storms, streamline script governance, and enforce fine‑grained multi‑tenant control, backed by concrete architecture diagrams, production‑grade Java code, capacity planning, monitoring, rollout procedures, and real‑world benchmark results.

ACLHigh ConcurrencyRedis
0 likes · 41 min read
Taming Message Storms: Redis 7.x Engineering Practices for Enterprise Live‑Streaming Platforms
macrozheng
macrozheng
Aug 6, 2026 · Databases

RedisInsight: A Stunning Official Redis Visualization Tool with Powerful Features

This article introduces RedisInsight, the official Redis visualization tool, walks through its Docker-based installation, showcases its graphical interface for data types, built-in workbench, slow‑log and memory analysis, JSON editing, theme switching, and provides a quick hands‑on experience for beginners.

Database ManagementDockerRedis
0 likes · 5 min read
RedisInsight: A Stunning Official Redis Visualization Tool with Powerful Features
Code Farming
Code Farming
Aug 5, 2026 · Backend Development

How to Generate Billions of Conflict‑Free Short URLs

The article breaks down a real‑world architecture for a short‑URL service that must handle 12 billion entries and 40 k QPS, showing how to calculate capacity, compare generation algorithms, use Bloom filters for offline de‑duplication, and employ a three‑layer cache‑plus‑storage design to meet performance goals.

Bloom FilterHBaseHigh Concurrency
0 likes · 7 min read
How to Generate Billions of Conflict‑Free Short URLs
liandk
liandk
Aug 5, 2026 · Databases

Mastering Redis High Availability: Replication, Sentinel, and Cluster Explained

The article explains why Redis must be highly available and walks through three progressive architectures—master‑slave replication, Sentinel automatic failover, and Redis Cluster—detailing their mechanisms, advantages, drawbacks, and when to choose each for small, medium, or large‑scale production systems.

ClusterDatabase ScalingOperations
0 likes · 7 min read
Mastering Redis High Availability: Replication, Sentinel, and Cluster Explained
Architect's Guide
Architect's Guide
Aug 5, 2026 · Databases

How to Combine Pagination and Multi‑Condition Fuzzy Search in Redis

This article explains how to implement pagination using Redis Sorted Sets, achieve multi‑condition fuzzy queries with Hashes and HSCAN, and then combine both techniques into a single solution while discussing performance trade‑offs and optimization strategies such as key expiration and data‑sync methods.

HSCANRedisSorted Set
0 likes · 9 min read
How to Combine Pagination and Multi‑Condition Fuzzy Search in Redis
Code Farming
Code Farming
Aug 4, 2026 · Backend Development

Why 50,000 Simultaneous Registrations Crashed the System—and How Isolation Prevents It

When an education company faced 50,000 concurrent re‑registration requests, its monolithic internal‑external architecture collapsed, but by physically separating networks, enforcing gateway rate‑limiting and circuit‑breaking, pre‑loading data into Redis, and using one‑way Kafka streams, the system remained stable.

Circuit BreakingHigh ConcurrencyKafka
0 likes · 6 min read
Why 50,000 Simultaneous Registrations Crashed the System—and How Isolation Prevents It
Random Bulletin
Random Bulletin
Aug 4, 2026 · Cloud Native

Stateless Design at Ten‑Million QPS: Moving State Out of Compute for Elastic Scaling

The article analyzes how local state—such as in‑memory sessions, caches, files, and long‑lived connections—breaks elastic scaling, outlines four concrete paths to externalize that state (Redis, JWT, object storage, and gateway separation), and explains the resulting scalability benefits, trade‑offs, and performance considerations.

KubernetesRedismicroservices
0 likes · 20 min read
Stateless Design at Ten‑Million QPS: Moving State Out of Compute for Elastic Scaling
Java Architect Handbook
Java Architect Handbook
Aug 3, 2026 · Databases

Redis Officially Launches RedisInsight: A Stunning GUI with Powerful Features

RedisInsight is a visual GUI for Redis that uniquely supports Redis Cluster, offers SSL/TLS connections, memory analysis and an integrated CLI; the article walks through downloading the package, configuring environment variables, starting the service on Linux, deploying it on Kubernetes with a YAML manifest, and using the UI to monitor and operate Redis instances.

GUIKubernetesMemory Analysis
0 likes · 8 min read
Redis Officially Launches RedisInsight: A Stunning GUI with Powerful Features
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 3, 2026 · Backend Development

Dynamic Data Permissions in Spring Boot: Row/Column-Level Control with MyBatis-Plus

This article details a production-ready dynamic data permission system using Spring Boot 3.x and MyBatis-Plus 3.5+, covering row-level interception via JSqlParser, column-level masking with Jackson serialization, RBAC+ABAC hybrid model, two-level caching with Caffeine and Redis, and lessons learned from handling complex JOINs, hot updates, and performance overhead.

ABACCaffeine CacheColumn-Level Masking
0 likes · 18 min read
Dynamic Data Permissions in Spring Boot: Row/Column-Level Control with MyBatis-Plus
samdeepthink
samdeepthink
Aug 3, 2026 · Backend Development

Is the Classic Update‑DB → Delete‑Cache → TTL Pattern Really the Best Way to Keep Cache Consistent?

The article examines why the common update‑database, delete‑cache, add‑TTL workflow can still produce permanent stale data under high concurrency, explains the underlying race conditions, and compares several alternative strategies—including delete‑first, binlog‑driven invalidation, and lease‑based approaches—to help engineers choose the most reliable and low‑complexity solution for cache consistency.

BinlogCache AsideConsistency
0 likes · 19 min read
Is the Classic Update‑DB → Delete‑Cache → TTL Pattern Really the Best Way to Keep Cache Consistent?
Lobster Programming
Lobster Programming
Aug 3, 2026 · Databases

How to Eliminate MySQL Master‑Slave Lag: Parallel Replication, Read‑Routing, and Redis Marking

To address MySQL master‑slave replication lag, the article explains enabling parallel replication (setting slave_parallel_workers), routing reads to the master for latency‑sensitive operations, and using a Redis short‑term marker to direct recent writes to the master, while outlining configuration steps and trade‑offs.

Database LagMySQLParallel Replication
0 likes · 6 min read
How to Eliminate MySQL Master‑Slave Lag: Parallel Replication, Read‑Routing, and Redis Marking
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 2, 2026 · Backend Development

Spring Boot + Spring Session: Distributed Session Management & Multi-Client Sync in Practice

This article provides a production-ready guide to replacing traditional HttpSession with Spring Session backed by Redis, covering multi-client session unification, performance tuning, security hardening, high-availability patterns, and practical Spring Boot 3.x configuration with code examples.

Distributed SessionMulti-clientRedis
0 likes · 19 min read
Spring Boot + Spring Session: Distributed Session Management & Multi-Client Sync in Practice
Java Baker
Java Baker
Jul 28, 2026 · Backend Development

Choosing the Right Distributed Lock: A Guide for Architects

Distributed locks are essential for coordinating access to shared resources across multiple machines; this article compares common solutions—Redis locks, database optimistic and logical locks, DB row locks, and Zookeeper locks—detailing their principles, pros, cons, implementation details, and best‑fit scenarios.

JavaOptimistic LockRedis
0 likes · 15 min read
Choosing the Right Distributed Lock: A Guide for Architects
AI Architect Hub
AI Architect Hub
Jul 27, 2026 · Databases

Secure Redis Upgrade Guide: Deploy Without Root Using a Regular User and Patch Critical Vulnerabilities

Most online Redis tutorials compile and run as root, creating serious security risks, so this guide walks through a complete, non‑root deployment and upgrade process—including backup, source compilation with a private prefix, configuration reuse, environment setup, post‑upgrade hardening, and a one‑click rollback—to safely patch high‑severity vulnerabilities on common Linux distributions.

LinuxRedisRootless Deployment
0 likes · 7 min read
Secure Redis Upgrade Guide: Deploy Without Root Using a Regular User and Patch Critical Vulnerabilities
Code Farming
Code Farming
Jul 26, 2026 · Backend Development

How Is a Red Envelope System Designed for High‑Concurrency?

This article breaks down the end‑to‑end design of a high‑traffic red‑envelope service, covering its three‑stage lifecycle, a fair double‑mean allocation algorithm, the need to separate grabbing from settlement, and how Redis, Lua scripts, and message queues handle massive concurrent requests.

BackendMessage QueueRedis
0 likes · 7 min read
How Is a Red Envelope System Designed for High‑Concurrency?
Cloud Architecture
Cloud Architecture
Jul 26, 2026 · Backend Development

Seckill System Architecture: 7 Core Design Strategies for High-Concurrency Sales

This article presents a comprehensive, step‑by‑step analysis of building a flash‑sale (seckill) system that can survive instant traffic spikes, detailing seven essential design ideas such as static page delivery, token gating, Redis atomic decrement, asynchronous queuing, multi‑layer rate limiting, service isolation, idempotent processing, and end‑to‑end monitoring and recovery.

High ConcurrencyLuaMQ
0 likes · 28 min read
Seckill System Architecture: 7 Core Design Strategies for High-Concurrency Sales
LuTiao Programming
LuTiao Programming
Jul 25, 2026 · Backend Development

Why Delayed Double Delete Fails: A Hierarchical Java Design for MySQL‑Redis Consistency

The article analyzes why MySQL and Redis cannot guarantee strong consistency with simple cache‑aside patterns, explains the pitfalls of delayed double delete, and presents a tiered Java design—including transaction‑after‑commit deletion, retryable invalidation, CDC/Outbox pipelines, TTL safeguards, and multi‑level cache considerations—to achieve reliable cache consistency.

CDCCache invalidationConsistency
0 likes · 22 min read
Why Delayed Double Delete Fails: A Hierarchical Java Design for MySQL‑Redis Consistency
Cloud Architecture
Cloud Architecture
Jul 25, 2026 · Backend Development

From MySQL to 10M QPS: A Full‑Stack Engineering Blueprint for High‑Throughput Transaction Systems

This white‑paper dissects why a monolithic MySQL‑based order service collapses under peak traffic and presents a layered, asynchronous architecture—using Redis for stock pre‑allocation, RocketMQ for transactional messaging, sharding, idempotency, and comprehensive observability—to reliably handle tens of millions of queries per second.

MySQLRedisRocketMQ
0 likes · 34 min read
From MySQL to 10M QPS: A Full‑Stack Engineering Blueprint for High‑Throughput Transaction Systems
samdeepthink
samdeepthink
Jul 25, 2026 · Backend Development

Designing a Hundred‑Million‑Scale Like System: Graph Store + KV Approach

The article analyzes the requirements of a massive‑scale like feature, compares small‑scale MySQL implementations with the graph‑plus‑KV architectures used by ByteDance, Kuaishou and Xiaohongshu, and presents a practical hybrid solution based on Redis, MySQL and batch processing to handle hot content and super‑node challenges.

IdempotenceKV storeMySQL
0 likes · 19 min read
Designing a Hundred‑Million‑Scale Like System: Graph Store + KV Approach
Architect's Guide
Architect's Guide
Jul 25, 2026 · Backend Development

The Art of Building a High‑Concurrency Flash‑Sale System

This article dissects the architecture of a massive flash‑sale service like 12306, covering multi‑layer load balancing, Nginx weighted round‑robin, stock‑deduction strategies, a Go‑based implementation with Redis and Lua, and performance results that demonstrate handling millions of concurrent ticket requests.

GoHigh ConcurrencyNginx
0 likes · 22 min read
The Art of Building a High‑Concurrency Flash‑Sale System
liandk
liandk
Jul 24, 2026 · Fundamentals

Why Every Project Needs Caching – Master Local and Distributed Cache Basics

The article explains the fundamental purpose of caching—placing frequently accessed data in faster storage—to dramatically reduce database load, compares local memory caches with distributed solutions like Redis, outlines their pros, cons, suitable scenarios, and presents a two‑level cache pattern plus common pitfalls such as cache penetration, breakdown, and avalanche.

CachingRedisdistributed cache
0 likes · 6 min read
Why Every Project Needs Caching – Master Local and Distributed Cache Basics
Black & White Path
Black & White Path
Jul 24, 2026 · Information Security

How Kimi K3 Uncovered Multiple Redis Zero‑Day RCE Bugs in Just 27 Minutes

In July 2026, the AI model Kimi K3 from Moonshot AI discovered and generated working remote‑code‑execution exploits for four Redis versions within 27 minutes, detailing a double‑free Stream NACK flaw and a TDigest heap overflow, and providing open‑source PoC scripts and defense guidance.

AI Vulnerability DiscoveryRedisexploit
0 likes · 9 min read
How Kimi K3 Uncovered Multiple Redis Zero‑Day RCE Bugs in Just 27 Minutes
Code Farming
Code Farming
Jul 22, 2026 · Backend Development

Designing a 5‑Layer Flash‑Sale System to Handle Millions of Requests

To survive a million concurrent flash‑sale clicks, the article breaks down a production‑grade, five‑layer architecture—CDN, load balancer, API gateway, Redis/Lua stock control, message‑queue order processing, and a state‑machine fallback—that filters traffic early, uses atomic operations, and decouples writes to keep database load to just a few QPS.

LuaMessage QueueMySQL
0 likes · 7 min read
Designing a 5‑Layer Flash‑Sale System to Handle Millions of Requests