0 views collected around this technical thread.
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.
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.
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.
Discover how Nacos 3.0 introduces a high‑availability distributed lock feature that eliminates the need for external services like Redis or ZooKeeper, learn step‑by‑step integration with Spring Boot, explore its core components, and unlock advanced extensibility via Java SPI.
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.
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.
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.
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.
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.
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.
The article explains how Spring AOP can cause object escape leading to concurrency safety problems, describes the impact of asynchronous threads and caching, and provides practical guidance on ordering AOP advices such as distributed lock, @Retryable, and dynamic datasource to avoid business anomalies.
Learn how to set up Redis with Docker, integrate it into a FastAPI app using a custom caching decorator, and apply Redis for caching API responses, rate limiting, task queues, and distributed locks, complete with practical code examples and deployment tips.
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.
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.
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.
This article introduces a comprehensive Spring Boot 3 practical case collection and walks through building a reentrant, auto‑renewing distributed lock using Redis and Lua scripts, providing full code snippets and configuration guidance for robust backend concurrency control.
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.
This article presents fifteen practical Redis usage scenarios—including caching, distributed locks, leaderboards, counters, message queues, session management, bitmap sign‑ins, geolocation, rate limiting, pub/sub, delayed tasks, global IDs, recommendation models, user follow relationships, and timeline feeds—each illustrated with concise code snippets.
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.
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.