BestHub
Sign in
Tagged articles
418 articles
Page 1 of 5
Ops Community
Ops Community
May 20, 2026 · Backend Development

Redis Cache Avalanche, Penetration, and Breakdown: The Three Must‑Know Issues for Interviews

This article explains the three classic Redis cache problems—avalanche, penetration, and breakdown—detailing their definitions, typical symptoms, step‑by‑step troubleshooting procedures, root‑cause analysis, and practical mitigation strategies such as random expiration, empty‑value caching, Bloom filters, distributed locks, and multi‑level cache architectures.

bloom-filtercache-avalanchecache-breakdown
0 likes · 35 min read
Redis Cache Avalanche, Penetration, and Breakdown: The Three Must‑Know Issues for Interviews
Su San Talks Tech
Su San Talks Tech
May 6, 2026 · Backend Development

11 Essential Redis Use Cases Every Backend Engineer Should Know

This article walks through eleven practical Redis scenarios—from classic caching and distributed locks to rate limiting, leaderboards, timelines, social graph operations, lightweight queues, Bloom filters, hash‑based object storage, unique‑counting, and delayed tasks—providing code samples, advantages, drawbacks, and when to apply each pattern.

Sorted SetStreambloom-filter
0 likes · 15 min read
11 Essential Redis Use Cases Every Backend Engineer Should Know
Architect's Tech Stack
Architect's Tech Stack
Apr 29, 2026 · Databases

Redis 8.0 Beyond Simple Caching: 16 Powerful Use Cases You Must Try

Redis 8.0 consolidates many previously external modules—JSON, time‑series, vector search, probabilistic data structures, and more—into a single package, and this article walks through 16 concrete scenarios ranging from field‑level cache expiration to AI‑ready vector similarity search, showing exact commands and when to prefer each feature.

Full‑Text SearchRedis 8.0caching
0 likes · 19 min read
Redis 8.0 Beyond Simple Caching: 16 Powerful Use Cases You Must Try
IoT Full-Stack Technology
IoT Full-Stack Technology
Apr 29, 2026 · Databases

16 Practical Redis Use Cases You Should Know

This article walks through sixteen common Redis scenarios—including caching hot data, sharing state across services, implementing distributed locks, generating global IDs, counting events, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, tagging, product filtering, and leaderboards—each illustrated with concrete commands and code snippets.

BitmapsMessage Queuecaching
0 likes · 9 min read
16 Practical Redis Use Cases You Should Know
IoT Full-Stack Technology
IoT Full-Stack Technology
Apr 29, 2026 · Databases

10+ Practical Redis Use Cases You Can Implement Today

This article walks through more than ten common Redis scenarios—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow/fan relationships, and ranking—showing concrete command examples and code snippets for each.

BitmapFollow SystemMessage Queue
0 likes · 9 min read
10+ Practical Redis Use Cases You Can Implement Today
Java Backend Full-Stack
Java Backend Full-Stack
Apr 26, 2026 · Databases

Mastering Redis: Core Concepts, Practical Roadmap, and Advanced Techniques

This comprehensive guide outlines a step‑by‑step learning path for Redis, covering foundational commands, core data structures, high‑performance internals, persistence options, clustering, common caching pitfalls, performance tuning, monitoring, source‑code exploration, and recommended resources for becoming a Redis expert.

ClusterData StructuresPersistence
0 likes · 9 min read
Mastering Redis: Core Concepts, Practical Roadmap, and Advanced Techniques
java1234
java1234
Apr 18, 2026 · Backend Development

Beyond Simple Caching: 8 Essential Redis Use Cases for Java Backend Engineers

This guide walks Java backend developers through Redis’s eight core scenarios—caching, distributed locks, rate limiting, session sharing, leaderboards, counters, message and delay queues, bitmap statistics, and geolocation—providing complete code, diagrams, and production‑grade best practices.

BitmapCacheGEO
0 likes · 21 min read
Beyond Simple Caching: 8 Essential Redis Use Cases for Java Backend Engineers
Coder Trainee
Coder Trainee
Apr 14, 2026 · Operations

5 Production Nightmares in an Education Mini‑Program and How to Avoid Them

The author recounts five critical production incidents that crippleed an education mini‑program—Redis connection‑pool exhaustion, duplicate bookings, double refunds, mis‑firing no‑show jobs, and inventory oversell—detailing root causes, concrete fixes, and hard‑won lessons for building resilient backend services.

IdempotencySpring Bootdistributed-lock
0 likes · 10 min read
5 Production Nightmares in an Education Mini‑Program and How to Avoid Them
Architect's Tech Stack
Architect's Tech Stack
Apr 10, 2026 · Backend Development

Unlock Redis: 12 Powerful Patterns Every Backend Engineer Should Know

Redis offers far more than simple key‑value caching; by leveraging its rich data structures—strings, hashes, lists, sets, sorted sets, bitmaps, HyperLogLog, GEO, and streams—developers can implement distributed locks, rate limiting, leaderboards, session storage, counters, geolocation, delayed queues, messaging, bloom filters, and more, all with concise commands.

Data Structurescachingdistributed-lock
0 likes · 9 min read
Unlock Redis: 12 Powerful Patterns Every Backend Engineer Should Know
java1234
java1234
Apr 5, 2026 · Databases

Beyond Caching: 16 Powerful Redis Use Cases

This article explores sixteen practical Redis applications—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, product tags, filtering, follow relationships, and ranking—demonstrating how Redis can serve as a versatile data store beyond simple caching.

BitmapsData StructuresMessage Queue
0 likes · 9 min read
Beyond Caching: 16 Powerful Redis Use Cases
Java Architect Handbook
Java Architect Handbook
Apr 4, 2026 · Backend Development

16 Powerful Redis Use Cases Every Backend Engineer Should Know

This article presents a comprehensive guide to 16 practical Redis applications—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, queues, lotteries, likes, product tagging, filtering, social graphs, and leaderboards—complete with command examples, code snippets, and visual illustrations to help developers implement these patterns efficiently.

BitmapCacheShopping Cart
0 likes · 11 min read
16 Powerful Redis Use Cases Every Backend Engineer Should Know
Architecture Digest
Architecture Digest
Apr 3, 2026 · Databases

16 Powerful Ways to Leverage Redis in Your Applications

This article presents a comprehensive guide to 16 practical Redis use cases—including caching, distributed locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow‑recommendation models, and ranking—complete with code snippets and data‑structure examples.

CacheData StructuresMessage Queue
0 likes · 10 min read
16 Powerful Ways to Leverage Redis in Your Applications
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 27, 2026 · Artificial Intelligence

How Tair Powers Sub‑Second AI Agent Memory for Real‑Time Ordering

This article examines how Taobao Flash Sale’s AI Agent uses Alibaba Cloud’s Tair as a high‑performance short‑term memory layer, detailing data model design, latency impact, concurrency control, elastic scaling, bandwidth handling, and TTL‑based cleanup to achieve sub‑second response times during massive traffic spikes.

AI AgentLow latencyMemory Management
0 likes · 15 min read
How Tair Powers Sub‑Second AI Agent Memory for Real‑Time Ordering
Code Ape Tech Column
Code Ape Tech Column
Jan 26, 2026 · Backend Development

Prevent Duplicate Spring @Scheduled Jobs in Multi‑Instance Deployments with ShedLock

When a Spring Boot application using @Scheduled is deployed on multiple servers, each instance triggers the same job, leading to duplicate processing; this article explains why the problem occurs, reviews simple single‑node and Redis lock approaches, and provides a step‑by‑step guide to integrate the ShedLock framework for reliable, annotation‑driven distributed locking.

@ScheduledJavaShedLock
0 likes · 8 min read
Prevent Duplicate Spring @Scheduled Jobs in Multi‑Instance Deployments with ShedLock
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jan 19, 2026 · Backend Development

How to Ensure Single-Node Execution of Spring Boot @Scheduled Tasks in Distributed Environments

This guide explains why @Scheduled jobs run on every Spring Boot instance in a cluster, and presents three practical solutions—Spring Integration's Redis lock, Redisson, and ShedLock—complete with Maven dependencies, configuration snippets, code examples, and runtime screenshots to guarantee that only one node executes the scheduled task at a time.

Backend DevelopmentScheduled TasksShedLock
0 likes · 9 min read
How to Ensure Single-Node Execution of Spring Boot @Scheduled Tasks in Distributed Environments
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Dec 23, 2025 · Backend Development

Mastering Redis Distributed Locks: From SETNX to RedLock and WatchDog

This article walks through the evolution of Redis distributed locks—from basic SETNX mutual exclusion to atomic SET with expiration, Lua‑based safe unlocking, Redisson's WatchDog auto‑renewal, and the RedLock algorithm—highlighting pitfalls, best‑practice implementations, and interview‑style Q&A for robust production use.

JavaRedlockWatchdog
0 likes · 15 min read
Mastering Redis Distributed Locks: From SETNX to RedLock and WatchDog
NiuNiu MaTe
NiuNiu MaTe
Dec 17, 2025 · Backend Development

Master Redis Distributed Locks: Prevent Race Conditions, Zombie Locks, and Expiration Issues

This guide explains how Redis implements distributed locks, outlines common pitfalls such as lock contention, zombie locks, and mismatched expiration times, and provides step‑by‑step solutions—including single‑node SET commands, Redlock high‑availability algorithm, Lua‑based safe release, and best‑practice recommendations for real‑world deployments.

Redlockdistributed-lockhigh-availability
0 likes · 15 min read
Master Redis Distributed Locks: Prevent Race Conditions, Zombie Locks, and Expiration Issues
Tech Freedom Circle
Tech Freedom Circle
Dec 13, 2025 · Backend Development

What’s Wrong with Delayed Double Delete? How Top Tech Companies Elegantly Avoid It

The article explains the delayed double‑delete cache‑invalidation pattern, its four major drawbacks in high‑concurrency environments, and presents four production‑grade alternatives—event‑driven binlog updates, distributed‑lock with versioning, write‑through proxy layers, and logical‑delete with async cleanup—used by leading Chinese internet firms to achieve reliable data consistency.

Event-drivenVersioningcaching
0 likes · 21 min read
What’s Wrong with Delayed Double Delete? How Top Tech Companies Elegantly Avoid It
Tech Freedom Circle
Tech Freedom Circle
Dec 12, 2025 · Backend Development

Why Redisson’s Reentrant Distributed Lock Relies on HINCRBY Increment and Decrement

The article explains how Redisson implements a re‑entrant distributed lock using Redis hash structures and the atomic HINCRBY command to manage client identity, re‑entry counting, concurrency safety, and graceful release, providing a complete technical analysis with code, Lua scripts, and best‑practice guidelines.

HINCRBYJavaLua Script
0 likes · 34 min read
Why Redisson’s Reentrant Distributed Lock Relies on HINCRBY Increment and Decrement
Architecture Digest
Architecture Digest
Dec 10, 2025 · Backend Development

How to Build a Mini Didi: Scalable Ride‑Hailing Architecture Explained

This article dissects the core architecture of a miniature ride‑hailing platform, covering domain‑driven design, layered microservice structure, Redis GEO for fast location queries, distributed locking, Netty‑based real‑time messaging, and hot‑cold data separation to handle massive traffic and ensure reliability.

NettyRedis GEORide Hailing
0 likes · 8 min read
How to Build a Mini Didi: Scalable Ride‑Hailing Architecture Explained
Java Companion
Java Companion
Nov 27, 2025 · Backend Development

Interview Question: How to Handle a Crashed Scheduled‑Task Server? Most Miss It

When a scheduled‑task server crashes, simply restarting it is insufficient; a robust solution must combine clustering, distributed locks, idempotent designs, checkpointing, and monitoring to ensure tasks resume correctly across non‑runtime and runtime failures, as detailed with SpringTask‑Redis and XXL‑JOB implementations.

BackendIdempotencyScheduled Tasks
0 likes · 28 min read
Interview Question: How to Handle a Crashed Scheduled‑Task Server? Most Miss It
Top Architect
Top Architect
Nov 9, 2025 · Backend Development

Mastering Idempotency: 4 Proven Techniques for Reliable Backend Operations

This article explains four common idempotency strategies—token, database unique index, distributed lock, and request‑body digest—detailing their core ideas, key concepts, and providing ready‑to‑copy Spring/Redis code examples to prevent duplicate requests in high‑traffic backend systems.

IdempotencyTokenUnique Index
0 likes · 10 min read
Mastering Idempotency: 4 Proven Techniques for Reliable Backend Operations
Architect
Architect
Nov 7, 2025 · Backend Development

Mastering Idempotency: 4 Proven Strategies for Reliable APIs

This article explains four practical idempotency solutions—token tokens, database unique indexes, distributed locks, and request content digests—detailing their concepts, core keywords, and providing ready‑to‑copy Spring Boot code examples, along with implementation tips and a comparison table to help you choose the right approach for high‑concurrency APIs.

Database IndexIdempotencySpring Boot
0 likes · 10 min read
Mastering Idempotency: 4 Proven Strategies for Reliable APIs
Top Architect
Top Architect
Oct 30, 2025 · Backend Development

How to Prevent Duplicate Submissions in Java APIs with Redis and Redisson

This article explains the concept of debounce for backend APIs, identifies which endpoints need it, and provides two distributed solutions—shared Redis cache and Redisson lock—complete with annotations, key generation logic, code examples, testing results, and tips for achieving true idempotency.

Backend DevelopmentIdempotencyJava
0 likes · 16 min read
How to Prevent Duplicate Submissions in Java APIs with Redis and Redisson
Architect
Architect
Oct 23, 2025 · Backend Development

Mastering tldb Distributed Locks: Go, Java, and Python Examples

This article explains how tldb implements language‑agnostic distributed locks, describes the Lock, TryLock, and Unlock APIs, and provides practical Go and Java code samples along with test results to help developers integrate reliable distributed locking into their systems.

Godistributed-lockmq client
0 likes · 8 min read
Mastering tldb Distributed Locks: Go, Java, and Python Examples
Open Source Tech Hub
Open Source Tech Hub
Oct 22, 2025 · Databases

What’s New in Valkey 9.0? Key Features and Performance Boosts Explained

Valkey 9.0, the latest community‑driven fork of Redis, introduces multi‑path TCP support, per‑field hash expiration, atomic slot migration, and new safety commands, offering developers enhanced performance, finer‑grained data control, and more reliable cluster operations.

Cluster MigrationHash expirationIn‑memory database
0 likes · 7 min read
What’s New in Valkey 9.0? Key Features and Performance Boosts Explained
Code Wrench
Code Wrench
Sep 30, 2025 · Backend Development

Mastering Go-Redis: High‑Performance Caching, Locks, and Queues

This tutorial walks through why Redis is essential for Go services, how to choose and install the go‑redis client, and provides step‑by‑step code for connections, common commands, cache‑aside, distributed locks, leaderboards, and lightweight queues, followed by performance tuning and best‑practice recommendations.

Gocachingdistributed-lock
0 likes · 8 min read
Mastering Go-Redis: High‑Performance Caching, Locks, and Queues
Programmer DD
Programmer DD
Sep 28, 2025 · Backend Development

How to Ensure Spring Boot Scheduled Tasks Run Only Once with ShedLock

Learn how to prevent duplicate execution of Spring Boot @Scheduled tasks in multi-instance deployments by integrating ShedLock, including Maven dependencies, H2 database setup, LockProvider configuration, and annotation usage to ensure each job runs only once across all nodes.

JavaScheduled TasksShedLock
0 likes · 6 min read
How to Ensure Spring Boot Scheduled Tasks Run Only Once with ShedLock
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 21, 2025 · Backend Development

Mastering Idempotent Payment APIs: From Pitfalls to Distributed‑Lock Solutions

This article walks through the evolution of a payment API’s idempotency design—from an initially flawed implementation, through naive Redis deduplication and token‑based approaches, to a robust solution that combines distributed locks, double‑checked caching, and state management for reliable, concurrent processing.

Idempotencydistributed-lockpayment
0 likes · 13 min read
Mastering Idempotent Payment APIs: From Pitfalls to Distributed‑Lock Solutions
Didi Tech
Didi Tech
Aug 14, 2025 · Backend Development

How RocketMQ and DDMQ Achieve Ordered Consumption: Deep Source Code Dive

This article deeply explores the ordered consumption mechanisms of RocketMQ and its derivative DDMQ, explaining the implementation differences, source‑code details of sequential sending, broker locking, client‑side processing, and compares the two systems' approaches to guarantee message order.

DDMQJavaMessage Queue
0 likes · 30 min read
How RocketMQ and DDMQ Achieve Ordered Consumption: Deep Source Code Dive
Sanyou's Java Diary
Sanyou's Java Diary
Aug 7, 2025 · Backend Development

How Easy-Cache Solves Distributed Cache Pain Points with Multi-Level Design

This article introduces Easy-Cache, a Spring-AOP based caching framework that provides annotation-driven, multi-level Redis and local cache with dynamic upgrade/downgrade, elastic expiration, and Lua-script-ensured data consistency, eliminating repetitive cache code and handling failures, cache penetration, breakdown, and eventual consistency challenges.

CacheLuaMulti-level Cache
0 likes · 18 min read
How Easy-Cache Solves Distributed Cache Pain Points with Multi-Level Design
Code Ape Tech Column
Code Ape Tech Column
Jul 24, 2025 · Backend Development

Mastering Redisson Distributed Locks: Deep Dive into Implementation, Reentrancy, and Fairness

This article provides a comprehensive guide to Redisson's distributed lock implementation, covering its architecture, comparison with Jedis and Lettuce, basic lock creation, Lua scripts for atomic operations, reentrant lock handling, watchdog-based lock renewal, RLock usage, and the design of fair locks using Redis data structures.

distributed-lockfair lockredis
0 likes · 31 min read
Mastering Redisson Distributed Locks: Deep Dive into Implementation, Reentrancy, and Fairness
Top Architect
Top Architect
Jul 8, 2025 · Backend Development

How to Build a Robust Redis Distributed Lock with AOP and Auto‑Renewal

This article explains how to protect time‑consuming business operations using a Redis‑based distributed lock implemented with a custom annotation, Spring AOP interception, automatic lock renewal via a scheduled executor, and proper lock release, ensuring data consistency across concurrent requests.

aopconcurrencydistributed-lock
0 likes · 14 min read
How to Build a Robust Redis Distributed Lock with AOP and Auto‑Renewal
Lobster Programming
Lobster Programming
Jul 7, 2025 · Backend Development

Boost Order Processing Speed with Segmented Locks and Redis

This article explains how to use segmented (sharded) locks and Redis‑based routing strategies to parallelize inventory deduction and order creation, dramatically increasing orders processed per second while maintaining atomicity and fault tolerance.

concurrencydistributed-lockorder processing
0 likes · 7 min read
Boost Order Processing Speed with Segmented Locks and Redis
Architect
Architect
Jul 5, 2025 · Backend Development

Implementing a Robust Redis Distributed Lock with AOP and Auto-Extension in Java

Learn how to design and implement a Redis-based distributed lock in Java using custom annotations, AOP interception, and a scheduled executor to automatically extend lock expiration, ensuring safe concurrent access to critical resources while handling timeouts, retries, and thread interruptions.

Javaaopconcurrency
0 likes · 12 min read
Implementing a Robust Redis Distributed Lock with AOP and Auto-Extension in Java
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Jun 16, 2025 · Backend Development

Mastering ZooKeeper: 7 Real-World Use Cases and Code Samples

ZooKeeper is an open‑source distributed coordination service that provides a simple, efficient mechanism for managing shared state, and this guide explores seven typical scenarios—including distributed locks, service registration, configuration management, queues, leader election, notifications, and barriers—complete with Java code examples and usage details.

Configuration ManagementDistributed CoordinationJava
0 likes · 9 min read
Mastering ZooKeeper: 7 Real-World Use Cases and Code Samples
Top Architect
Top Architect
Jun 4, 2025 · Backend Development

Implementing Request Debounce in Java Backend Using Redis and Redisson

This article explains how to implement request debouncing in Java backend services using Redis and Redisson, covering the concept, interface types needing debouncing, duplicate request detection, shared cache and distributed lock solutions, with complete code examples and testing results.

BackendDebounceJava
0 likes · 17 min read
Implementing Request Debounce in Java Backend Using Redis and Redisson
Java Captain
Java Captain
Jun 3, 2025 · Backend Development

Implementation of Order Service with Distributed Transactions, Locks, and Asynchronous Processing in Java

This article explains how to build a robust order service using Seata distributed transactions, Redisson distributed locks, CompletableFuture for asynchronous operations, token-based duplicate‑submission prevention, and RabbitMQ delayed queues for automatic order cancellation, with full Java code examples.

Seatadistributed-lockdistributed-transaction
0 likes · 21 min read
Implementation of Order Service with Distributed Transactions, Locks, and Asynchronous Processing in Java
Lobster Programming
Lobster Programming
May 30, 2025 · Backend Development

How to Ensure API Idempotency with Locks: 5 Proven Strategies

This article explores five practical lock-based approaches—including database primary keys, pessimistic and optimistic locks, state machines, and distributed locks—to achieve reliable API idempotency in distributed systems, highlighting implementation details, trade‑offs, and code examples.

API idempotencydatabase lockdistributed-lock
0 likes · 7 min read
How to Ensure API Idempotency with Locks: 5 Proven Strategies
Java Architect Essentials
Java Architect Essentials
May 20, 2025 · Backend Development

Ensuring Idempotency with Distributed Locks: Adjusting Aspect Order in Java Backend

This article explains how using a custom @DistributeLock annotation together with @Transactional can cause idempotency issues due to aspect execution order, and demonstrates how to prioritize the lock aspect using @Order to ensure the lock is applied before the transaction, with code examples and best‑practice recommendations.

IdempotencyJavaaspect order
0 likes · 6 min read
Ensuring Idempotency with Distributed Locks: Adjusting Aspect Order in Java Backend
Java Tech Enthusiast
Java Tech Enthusiast
May 17, 2025 · Backend Development

How to Implement Distributed API Debounce in Java with Redis and Redisson

This article explains why API debounce is needed in web back‑ends, identifies the types of endpoints that require it, outlines how to detect duplicate requests, and provides two concrete distributed solutions—shared Redis cache and Redisson lock—complete with annotation design, key generation logic, and full Java code examples.

API DebounceIdempotencyJava
0 likes · 15 min read
How to Implement Distributed API Debounce in Java with Redis and Redisson
IT Xianyu
IT Xianyu
May 8, 2025 · Databases

Redis for DBAs: Quick Installation, Core Commands, Caching Design Patterns, and High‑Concurrency Practices

This article explains why Redis is becoming a DBA's favorite, provides a five‑minute installation guide, essential commands, cache‑design pitfalls and solutions, explores Redis data structures with Java examples, demonstrates distributed locking and flash‑sale implementations, and covers clustering, backup, monitoring, and performance tuning.

ClusterJavadistributed-lock
0 likes · 9 min read
Redis for DBAs: Quick Installation, Core Commands, Caching Design Patterns, and High‑Concurrency Practices
Sohu Tech Products
Sohu Tech Products
May 7, 2025 · Backend Development

Design and Implementation of a Scalable Lottery Activity Platform

The article describes how the FoxFriend team built a scalable, configurable lottery‑activity platform that replaces manual feed‑based draws with a modular micro‑service architecture, featuring a flexible prize‑tier data model, pre‑occupied inventory buckets, multi‑tenant isolation, high‑concurrency stock deduction, user risk controls, accurate probability handling, and a roadmap toward AI‑driven optimization.

Backend DevelopmentLottery Systemdistributed-lock
0 likes · 25 min read
Design and Implementation of a Scalable Lottery Activity Platform
Architect
Architect
May 1, 2025 · Cloud Native

What’s New in Nacos 3.0? A Deep Dive into Its Cloud‑Native Enhancements

This article summarizes the key changes from the Nacos 3.0 beta to the official release, covering JDK and Spring Boot upgrades, new Admin APIs, default authentication, AI Model Content Protocol, unified namespaces, beta distributed lock, fuzzy listening, and native xDS support for cloud‑native microservice architectures.

AI integrationCloud NativeConfiguration Management
0 likes · 7 min read
What’s New in Nacos 3.0? A Deep Dive into Its Cloud‑Native Enhancements
macrozheng
macrozheng
Apr 28, 2025 · Cloud Native

Discover Nacos 3.0: AI‑Driven MCP, Distributed Locks, and Native xDS Support

Version 3.0 of Nacos upgrades to JDK 17 and Spring Boot 3.4.1, introduces AI‑focused MCP, enhanced Admin API with default authentication, unified namespaces, beta distributed lock and fuzzy listening features, and native xDS protocol support, while highlighting related open‑source SpringBoot + Vue e‑commerce projects.

AICloud NativeMicroservices
0 likes · 7 min read
Discover Nacos 3.0: AI‑Driven MCP, Distributed Locks, and Native xDS Support
Java Architecture Diary
Java Architecture Diary
Apr 27, 2025 · Cloud Native

What’s New in Nacos 3.0? Key Features, AI Integration, and Cloud‑Native Enhancements

Nacos 3.0 introduces major upgrades—including JDK 17 and Spring Boot 3.4.1 support, a new Admin API, default authentication, AI‑focused MCP, unified namespaces, beta distributed lock and fuzzy listening features, plus native xDS protocol support—positioning it as a powerful cloud‑native service discovery and configuration platform.

AI integrationCloud NativeNacos
0 likes · 6 min read
What’s New in Nacos 3.0? Key Features, AI Integration, and Cloud‑Native Enhancements
Java Tech Enthusiast
Java Tech Enthusiast
Apr 19, 2025 · Backend Development

Preventing Product Overselling in High‑Concurrency E‑Commerce Systems

To prevent overselling during flash sales, the article explains how non‑atomic database updates cause negative stock and presents solutions such as optimistic DB locking, Redis Lua atomic deductions, Redisson distributed locks, transactional message queues, and pre‑deduction with rate limiting, recommending a combined approach that achieved 120 000 QPS with zero oversell.

distributed-lockinventory managementoptimistic lock
0 likes · 7 min read
Preventing Product Overselling in High‑Concurrency E‑Commerce Systems
IT Services Circle
IT Services Circle
Apr 18, 2025 · Backend Development

Preventing Duplicate Orders under 100k QPS: Full‑Stack Strategies

This article explains how to prevent duplicate orders in a high‑traffic system handling 100,000 QPS by combining frontend safeguards such as button disabling and token mechanisms with backend techniques including NGINX rate limiting, gateway token validation, idempotent database design, sharding, distributed locks, optimistic locking, and comprehensive logging and monitoring.

Idempotencybackend designdistributed-lock
0 likes · 7 min read
Preventing Duplicate Orders under 100k QPS: Full‑Stack Strategies
Ma Wei Says
Ma Wei Says
Apr 5, 2025 · Backend Development

Ensuring Accurate Inventory Deduction in High‑Concurrency Sales with Redis

This article explains why simple GET‑modify‑SET inventory updates cause overselling in flash‑sale spikes and presents several Redis‑based solutions—including Lua scripts, WATCH‑based optimistic locks, distributed SETNX locks, and asynchronous queue processing—detailing their implementation, advantages, and trade‑offs.

BackendLua Scriptconcurrency
0 likes · 8 min read
Ensuring Accurate Inventory Deduction in High‑Concurrency Sales with Redis
Raymond Ops
Raymond Ops
Apr 4, 2025 · Databases

Mastering Redis: Persistence, Cache Pitfalls, Data Types, Clustering & Locks

This article explains Redis persistence mechanisms (RDB and AOF), common cache problems and their solutions, the various Redis data structures and their use cases, cluster deployment options, master‑slave replication, transaction commands, and how to implement distributed locks with SETNX and expiration.

CacheData TypesPersistence
0 likes · 13 min read
Mastering Redis: Persistence, Cache Pitfalls, Data Types, Clustering & Locks
Selected Java Interview Questions
Selected Java Interview Questions
Apr 4, 2025 · Backend Development

Guide to Using Lock4j Distributed Lock Component in Spring Boot

This article introduces the Lock4j distributed lock library, explains its features, shows how to add Maven dependencies, configure Redis, use the @Lock4j annotation for simple and advanced locking scenarios, and provides custom executor, key builder, and failure‑strategy examples for Spring Boot applications.

Lock4jSpring BootZooKeeper
0 likes · 6 min read
Guide to Using Lock4j Distributed Lock Component in Spring Boot
Su San Talks Tech
Su San Talks Tech
Mar 11, 2025 · Backend Development

7 Proven Retry Strategies to Keep Your System Running Smoothly

This article explores seven practical retry solutions—from simple loops and Spring Retry to Resilience4j, message queues, scheduled tasks, two‑phase commits, and distributed locks—explaining their scenarios, core code, and how they prevent costly system failures.

BackendMQRetry
0 likes · 10 min read
7 Proven Retry Strategies to Keep Your System Running Smoothly
macrozheng
macrozheng
Feb 25, 2025 · Databases

Master Redis: 16 Real-World Patterns for Caching, Locks, and More

This guide explores 16 practical Redis use cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, product tags, filtering, follow models, and ranking—providing code snippets and implementation tips for each pattern.

Bitmapsdistributed-lockredis
0 likes · 9 min read
Master Redis: 16 Real-World Patterns for Caching, Locks, and More
Selected Java Interview Questions
Selected Java Interview Questions
Feb 18, 2025 · Backend Development

Why Java synchronized Is Insufficient in Distributed Systems and Alternative Lock Solutions

The article explains how Java's synchronized keyword works only within a single JVM, why it fails to provide mutual exclusion across multiple processes in distributed systems, and presents alternative distributed locking mechanisms such as database locks and Redis-based locks with code examples.

Javaconcurrencydatabase lock
0 likes · 8 min read
Why Java synchronized Is Insufficient in Distributed Systems and Alternative Lock Solutions
Lobster Programming
Lobster Programming
Feb 10, 2025 · Backend Development

How to Choose the Right Distributed Lock: DB, Redis, or ZooKeeper?

This article explains the concept of distributed locks and compares three common implementation approaches—using a database, Redis, and ZooKeeper—detailing their mechanisms, advantages, drawbacks, and suitable scenarios for ensuring consistent access to shared resources in distributed systems.

BackendZooKeeperconcurrency
0 likes · 7 min read
How to Choose the Right Distributed Lock: DB, Redis, or ZooKeeper?
Java Backend Technology
Java Backend Technology
Feb 4, 2025 · Backend Development

How to Implement Real-Time Overdue Task Alerts with Redis Key Expiration and Strategy Pattern

This article explains how to use Redis key expiration notifications combined with a strategy pattern to create real‑time overdue reminders for workflow tasks, covering configuration, listener implementation, distributed locking, message handling, and practical usage in a SpringBoot project.

Key ExpirationSpringBootStrategy Pattern
0 likes · 13 min read
How to Implement Real-Time Overdue Task Alerts with Redis Key Expiration and Strategy Pattern
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Feb 3, 2025 · Backend Development

Code Review of Coupon Claim and Approval Workflow: Issues and Optimization Strategies

This article reviews Java Spring code for a coupon claim and approval workflow, identifies concurrency and transaction issues such as missing locks and inconsistent update order, and proposes optimizations including user‑level locking, simplifying lock management, and aligning transactional update sequences to prevent deadlocks.

Code reviewJavaconcurrency
0 likes · 12 min read
Code Review of Coupon Claim and Approval Workflow: Issues and Optimization Strategies
Code Ape Tech Column
Code Ape Tech Column
Jan 22, 2025 · Backend Development

Using Lua Scripts with Spring Boot and Redis: A Comprehensive Guide

This article introduces Lua scripting in Redis, explains its fundamentals and advantages, and provides step‑by‑step instructions for integrating and executing Lua scripts within a Spring Boot application, including code examples, performance optimization, error handling, security considerations, and best practices.

Error HandlingLuaSpring Boot
0 likes · 19 min read
Using Lua Scripts with Spring Boot and Redis: A Comprehensive Guide
Architecture Digest
Architecture Digest
Jan 10, 2025 · Backend Development

Implementing a Distributed Redis Lock with Spring AOP and Automatic Renewal

This article explains how to protect time‑consuming business operations and critical data by designing a Redis‑based distributed lock using custom annotations, Spring AOP, and a ScheduledExecutorService that automatically extends the lock’s expiration to avoid premature release.

JavaScheduledExecutorServiceconcurrency
0 likes · 11 min read
Implementing a Distributed Redis Lock with Spring AOP and Automatic Renewal
Architect
Architect
Dec 8, 2024 · Backend Development

16 Essential Redis Patterns Every Backend Engineer Should Master

This article compiles sixteen practical Redis use‑cases—from caching and distributed locks to rate limiting, bitmaps, shopping carts, timelines, queues, likes, tags, filtering, follow/fan relationships, and leaderboards—providing code snippets and command examples to help backend developers design scalable systems.

BackendDesign Patternscaching
0 likes · 11 min read
16 Essential Redis Patterns Every Backend Engineer Should Master
vivo Internet Technology
vivo Internet Technology
Nov 27, 2024 · Backend Development

Implementation Principles of Distributed Locks with Redis and Zookeeper

Distributed locks synchronize multiple services across nodes, and can be implemented using Redis’s fast, AP‑oriented SET‑NX with automatic TTL renewal or Zookeeper’s CP‑oriented ephemeral sequential nodes, each offering distinct trade‑offs in performance, consistency, and suitability for various workload requirements.

CAP theoremJavaZooKeeper
0 likes · 24 min read
Implementation Principles of Distributed Locks with Redis and Zookeeper
Top Architect
Top Architect
Nov 12, 2024 · Backend Development

Preventing Duplicate Submissions in Java Backend with Debounce and Distributed Locks

This article explains how to implement request debouncing and distributed locking in a Java backend using Redis and Redisson, covering the definition of debounce, identifying suitable APIs, generating unique keys, and providing complete code examples for both cache‑based and Redisson‑based lock mechanisms.

DebounceJavaSpringBoot
0 likes · 17 min read
Preventing Duplicate Submissions in Java Backend with Debounce and Distributed Locks
Architect
Architect
Nov 10, 2024 · Backend Development

How to Prevent Duplicate Submissions in Java APIs with Redis and Redisson Locks

This article explains why API debouncing is crucial for backend Java services, outlines which endpoints need protection, describes how to identify duplicate requests, and provides step‑by‑step implementations using Redis shared‑cache and Redisson distributed locks with concrete code examples and test results.

BackendDebounceJava
0 likes · 14 min read
How to Prevent Duplicate Submissions in Java APIs with Redis and Redisson Locks
JD Retail Technology
JD Retail Technology
Nov 5, 2024 · Backend Development

Ensuring Inventory Consistency Under Concurrent Operations: Locking Pitfalls and Solutions

The article examines how frequent inventory adjustments in JD retail supply‑chain can suffer from concurrency issues, explains why traditional locking may fail, analyzes a real‑world case of lock misuse, and presents code‑level, database‑level, and architectural solutions to guarantee data consistency.

Consistencyconcurrencydatabase
0 likes · 7 min read
Ensuring Inventory Consistency Under Concurrent Operations: Locking Pitfalls and Solutions
Java Backend Full-Stack
Java Backend Full-Stack
Sep 21, 2024 · Backend Development

How a Full‑Stack Charging‑Station Project Can Boost Your Interview Portfolio

This article walks through a zero‑to‑one charging‑station system built with Spring Cloud microservices, Vue front‑end, and a suite of enterprise features such as distributed locks, idempotency, multi‑level caching, and custom starters, providing concrete design documents and module breakdowns to help candidates showcase real project experience in interviews.

Charging StationDesign PatternsIdempotency
0 likes · 9 min read
How a Full‑Stack Charging‑Station Project Can Boost Your Interview Portfolio
Top Architect
Top Architect
Sep 20, 2024 · Backend Development

Implementing Interface Debounce with Distributed Locks in Java Backend Systems

This article explains the concept of request debouncing, identifies which API endpoints need it, and demonstrates two distributed lock solutions—shared Redis cache and Redisson—by providing complete Java code examples, configuration steps, and test results to prevent duplicate submissions in backend services.

DebounceJavadistributed-lock
0 likes · 17 min read
Implementing Interface Debounce with Distributed Locks in Java Backend Systems
Java Architect Essentials
Java Architect Essentials
Sep 17, 2024 · Backend Development

Using tldb Distributed Lock with Go and Java Clients

This article introduces tldb's distributed lock, explains its lock, trylock, and unlock methods, and provides step‑by‑step Go and Java client examples—including Maven configuration and code snippets—for acquiring and releasing locks across languages in a distributed environment.

JavaMQdistributed-lock
0 likes · 8 min read
Using tldb Distributed Lock with Go and Java Clients
Architecture Digest
Architecture Digest
Aug 25, 2024 · Backend Development

Lock4j Distributed Lock Component: Features, Configuration, and Usage Guide

Lock4j is a Java distributed lock library supporting Spring AOP, RedisTemplate, Redisson, and Zookeeper, offering simple usage, configurable properties, annotation-driven locking, custom executors, key generators, and failure strategies, with detailed setup, code examples, and advanced customization instructions.

Backend DevelopmentJavaSpring Boot
0 likes · 6 min read
Lock4j Distributed Lock Component: Features, Configuration, and Usage Guide
Java Backend Technology
Java Backend Technology
Aug 23, 2024 · Backend Development

How to Implement Distributed API Debounce with Redis and Redisson in Java

This article explains why API debounce is essential, identifies the types of endpoints that need it, and provides two distributed solutions—shared Redis cache and Redisson lock—along with complete Java code examples and deployment tips for preventing duplicate submissions in a Spring Boot backend.

API idempotencyDebounceJava
0 likes · 16 min read
How to Implement Distributed API Debounce with Redis and Redisson in Java
Top Architect
Top Architect
Aug 21, 2024 · Backend Development

Handling Redis Cache Penetration, Avalanche, and Breakdown in High‑Concurrency Scenarios

This article explains the four common Redis cache pitfalls—cache penetration, avalanche, breakdown, and data inconsistency—demonstrates how they can crash high‑traffic systems, and provides practical Java/Spring Boot solutions such as empty‑object caching, Bloom filters, distributed locks, and delayed double‑delete strategies.

Data ConsistencyJavaSpring Boot
0 likes · 27 min read
Handling Redis Cache Penetration, Avalanche, and Breakdown in High‑Concurrency Scenarios
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 6, 2024 · Operations

ZooKeeper Core Concepts: Data Model, Node Types, Sessions, Cluster, Election, ZAB, Watch, ACL, and Distributed Lock Patterns

This article explains ZooKeeper's hierarchical data model, node types, session mechanism, cluster roles and election process, ZAB protocol, watch mechanism, ACL permissions, and common distributed lock implementations, providing a comprehensive overview of its core concepts and practical usage.

ACLCluster ManagementCoordination Service
0 likes · 17 min read
ZooKeeper Core Concepts: Data Model, Node Types, Sessions, Cluster, Election, ZAB, Watch, ACL, and Distributed Lock Patterns
Java High-Performance Architecture
Java High-Performance Architecture
Aug 4, 2024 · Backend Development

Unlock Java Distributed Locks with Lock4j: Guide & Advanced Tips

This article introduces Lock4j, a Java distributed lock library supporting RedisTemplate, Redisson, and Zookeeper, walks through its key features, dependency setup, configuration, annotation attributes, simple and advanced usage examples, and demonstrates custom executors, key builders, and failure strategies for robust concurrency control.

JavaLock4jSpring Boot
0 likes · 6 min read
Unlock Java Distributed Locks with Lock4j: Guide & Advanced Tips
DeWu Technology
DeWu Technology
Jul 24, 2024 · Backend Development

Mastering Unique Identifiers and Distributed Locks: From UUIDs to CAS

This article explores how various unique identifier schemes—random UUIDs, sequential numbers, hierarchical paths, and distributed ID generators—are applied across programming languages, file systems, databases, and networks, and explains when and how to enforce uniqueness using pre‑validation, database constraints, or distributed locks such as Redis and Zookeeper, while also linking these mechanisms to CAS‑based concurrency control.

Backend DevelopmentCASDistributed Systems
0 likes · 23 min read
Mastering Unique Identifiers and Distributed Locks: From UUIDs to CAS
Java Tech Enthusiast
Java Tech Enthusiast
Jul 21, 2024 · Backend Development

Interface Performance Optimization Techniques for Backend Development

The article outlines practical backend interface performance optimizations—including proper indexing, SQL tuning, parallel remote calls, batch queries, asynchronous processing, scoped transactions, fine-grained locking, pagination batching, multi-level caching, sharding, and monitoring tools—to dramatically reduce latency and improve throughput.

SQL Optimizationasynchronous processingcaching
0 likes · 25 min read
Interface Performance Optimization Techniques for Backend Development
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 12, 2024 · Backend Development

Master Distributed Locks in Spring Boot with Lock4j: A Complete Guide

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.

Lock4jSpring Bootdistributed-lock
0 likes · 9 min read
Master Distributed Locks in Spring Boot with Lock4j: A Complete Guide
Architect
Architect
Jul 9, 2024 · Backend Development

Mastering Distributed Locks with Redis: From Simple SETNX to RedLock and Redisson

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.

BackendJavaRedlock
0 likes · 19 min read
Mastering Distributed Locks with Redis: From Simple SETNX to RedLock and Redisson