BestHub
Sign in
Tagged articles

distributed lock

459 articles · Page 4 of 5
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 24, 2021 · Backend Development

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

This article presents sixteen practical Redis use‑cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, tags, filtering, follow models, and ranking—explaining their data types, commands, and sample code.

BitmapCachingCounter
0 likes · 8 min read
Mastering Redis: 16 Real-World Patterns for Caching, Locks, Counters, and More
Sohu Tech Products
Sohu Tech Products
Sep 22, 2021 · Databases

Common Redis Use Cases and Implementation Patterns

This article introduces a collection of practical Redis use cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, product filtering, follow relationships, and ranking—explaining their data types, commands, and sample code.

BitmapsCachingLeaderboard
0 likes · 8 min read
Common Redis Use Cases and Implementation Patterns
Code Ape Tech Column
Code Ape Tech Column
Sep 15, 2021 · Backend Development

Designing a High‑Concurrency Flash‑Sale (Seckill) System: Key Techniques and Best Practices

This article explains how to design a high‑concurrency flash‑sale system by addressing instant traffic spikes, page static‑generation, CDN acceleration, button activation, read‑heavy/write‑light patterns, cache breakdown and penetration, inventory pre‑deduction, distributed locking, message‑queue handling, and multi‑level rate limiting.

CachingFlash SaleHigh Concurrency
0 likes · 23 min read
Designing a High‑Concurrency Flash‑Sale (Seckill) System: Key Techniques and Best Practices
Selected Java Interview Questions
Selected Java Interview Questions
Sep 9, 2021 · Backend Development

Preventing Overselling in Flash‑Sale (SecKill) Systems with a Redis Distributed Lock

This article explains how a naïve SpringBoot SecKill implementation can cause overselling, then introduces Redis commands (SETNX, EXPIRE, GETSET) and a custom RedisLock component to achieve safe distributed locking, avoid deadlocks, and ensure accurate inventory updates during high‑concurrency flash‑sale events.

JavaRedisSpringBoot
0 likes · 10 min read
Preventing Overselling in Flash‑Sale (SecKill) Systems with a Redis Distributed Lock
NiuNiu MaTe
NiuNiu MaTe
Sep 8, 2021 · Backend Development

Mastering Distributed Locks with Redis: From Basics to RedLock

This article explains what distributed locks are, outlines their essential properties, walks through step‑by‑step Redis implementations—from simple SETNX to Lua‑based atomic operations—and discusses reliability strategies such as master‑slave failover and RedLock while highlighting the inherent limits of any distributed lock.

Lua scriptingRedisdistributed lock
0 likes · 11 min read
Mastering Distributed Locks with Redis: From Basics to RedLock
Java Backend Technology
Java Backend Technology
Aug 31, 2021 · Backend Development

How to Build a High‑Performance Flash Sale System: 9 Essential Design Tips

This article explains how to design a flash‑sale (秒杀) system that can handle instant high concurrency by using page static‑generation, CDN acceleration, caching strategies, distributed locks, message‑queue async processing, stock pre‑deduction, rate limiting and other techniques to ensure reliability and prevent overselling.

Flash Saledistributed lock
0 likes · 28 min read
How to Build a High‑Performance Flash Sale System: 9 Essential Design Tips
Code Ape Tech Column
Code Ape Tech Column
Aug 29, 2021 · Backend Development

Understanding Idempotency and Preventing Duplicate Submissions in Backend Systems

This article explains the concept of idempotency, the common causes of duplicate submissions in web applications, and presents multiple backend solutions—including frontend button disabling, Post‑Redirect‑Get, session tokens, local locks with Content‑MD5, AOP aspects, and Redis distributed locks—accompanied by complete Java code examples.

AOPDuplicate SubmissionJava
0 likes · 15 min read
Understanding Idempotency and Preventing Duplicate Submissions in Backend Systems
Programmer DD
Programmer DD
Aug 22, 2021 · Backend Development

Mastering Distributed Locks with Redis: From Basics to Redisson

This article walks through the evolution of Redis‑based distributed locks, illustrating common pitfalls and step‑by‑step improvements—from simple set‑if‑absent locks to atomic UUID checks and Lua‑scripted releases, culminating in a robust Redisson solution.

JavaRedisSpring Boot
0 likes · 8 min read
Mastering Distributed Locks with Redis: From Basics to Redisson
Dada Group Technology
Dada Group Technology
Aug 13, 2021 · Backend Development

Inside JD Daojia’s After‑Sale System: Distributed Locks, Data Sync, and Refund Strategies

This article examines JD Daojia’s after‑sale platform, detailing its three‑tier architecture, distributed‑lock mechanisms for multi‑endpoint requests, complex promotion‑aware split‑data handling, Elasticsearch synchronization, combined‑order logistics, and rigorous refund validation to ensure accurate and performant service delivery.

BackendElasticsearchdata-sync
0 likes · 16 min read
Inside JD Daojia’s After‑Sale System: Distributed Locks, Data Sync, and Refund Strategies
Laravel Tech Community
Laravel Tech Community
Aug 12, 2021 · Backend Development

Cache Penetration, Cache Breakdown, and Cache Avalanche: Concepts and Solutions

The article explains the concepts of cache penetration, cache breakdown, and cache avalanche in Redis‑based systems, analyzes the performance problems they cause under high concurrency, and presents practical mitigation techniques such as Bloom filters, caching empty objects, distributed locks, high‑availability clusters, rate limiting, and data pre‑warming.

BackendBloom FilterRedis
0 likes · 6 min read
Cache Penetration, Cache Breakdown, and Cache Avalanche: Concepts and Solutions
Yang Money Pot Technology Team
Yang Money Pot Technology Team
Aug 4, 2021 · Backend Development

Design and Implementation of ylock: A Distributed ReentrantReadWriteLock Framework

This article explains the challenges of distributed locking, compares existing lock services, and details the design, implementation, and monitoring features of the ylock framework, which provides reentrant read‑write locks over Redis and Zookeeper with unified APIs and Spring Boot integration.

Spring BootZooKeeperdistributed lock
0 likes · 24 min read
Design and Implementation of ylock: A Distributed ReentrantReadWriteLock Framework
Java Architect Essentials
Java Architect Essentials
Aug 2, 2021 · Backend Development

Java Garbage Collection, JVM Memory Model, Concurrency Locks, Thread Pools and Distributed Locking

The article provides a comprehensive overview of Java garbage‑collection algorithms, JVM memory regions, object reachability analysis, the semantics of volatile, synchronized and ReentrantLock, thread‑pool creation and operation, deadlock examples, distributed‑lock strategies, and related tooling such as JUC utilities and Git conflict handling.

ConcurrencyGarbage CollectionJVM
0 likes · 23 min read
Java Garbage Collection, JVM Memory Model, Concurrency Locks, Thread Pools and Distributed Locking
Su San Talks Tech
Su San Talks Tech
Jul 29, 2021 · Backend Development

How to Build a High‑Performance Flash Sale System: 9 Essential Design Tips

Designing a flash‑sale (秒杀) system for massive concurrent users requires careful handling of instant traffic spikes, page staticization, CDN acceleration, caching strategies, distributed locks, rate limiting, asynchronous processing, and reliable stock management, with nine detailed techniques to ensure stability and prevent overselling.

CachingFlash SaleHigh Concurrency
0 likes · 26 min read
How to Build a High‑Performance Flash Sale System: 9 Essential Design Tips
Wukong Talks Architecture
Wukong Talks Architecture
Jul 25, 2021 · Backend Development

Understanding Cache Breakdown and Effective Mitigation Strategies

The article explains the concept of cache breakdown—when an expiring cache key triggers a surge of database requests—and presents three practical mitigation approaches: using never‑expire for immutable data, applying distributed or local locks for infrequently updated data, and employing scheduled pre‑warming or expiration extension for frequently changing or slow‑refreshing caches.

cache breakdowndistributed lock
0 likes · 2 min read
Understanding Cache Breakdown and Effective Mitigation Strategies
Laravel Tech Community
Laravel Tech Community
Jul 23, 2021 · Backend Development

Cache Penetration, Cache Breakdown, and Cache Avalanche: Concepts and Mitigation Strategies

The article explains the concepts of cache penetration, cache breakdown, and cache avalanche in Redis‑based systems, describes the performance risks they pose to persistent databases, and presents practical mitigation techniques such as Bloom filters, empty‑object caching, hot‑key permanence, distributed locks, high‑availability clusters, rate limiting, and data pre‑warming.

BackendBloom FilterPerformance
0 likes · 6 min read
Cache Penetration, Cache Breakdown, and Cache Avalanche: Concepts and Mitigation Strategies
vivo Internet Technology
vivo Internet Technology
Jul 21, 2021 · Backend Development

Resolving Duplicate OpenID Insertions in Fast App Center: Analysis and Distributed Lock Solutions

The Fast App Center’s duplicate OpenID rows were traced to a non‑atomic check‑then‑insert race condition, prompting the team to evaluate a unique‑index safeguard versus application‑level distributed locking, ultimately implementing a Redis‑based lock to serialize inserts and adding a cleanup job to purge existing duplicates.

Database ConcurrencyJavaMySQL
0 likes · 18 min read
Resolving Duplicate OpenID Insertions in Fast App Center: Analysis and Distributed Lock Solutions
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 9, 2021 · Backend Development

Comprehensive Overview of Zookeeper: Architecture, Core Functions, Protocols, and Use Cases

This article provides a detailed introduction to Zookeeper, covering its definition as a distributed coordination service, core features such as a hierarchical file system, notification mechanism, and cluster management, various application scenarios, the ZAB protocol, node types, leader election process, distributed lock implementation, and watch mechanism, all illustrated with diagrams.

Distributed CoordinationLeader ElectionZAB Protocol
0 likes · 8 min read
Comprehensive Overview of Zookeeper: Architecture, Core Functions, Protocols, and Use Cases
macrozheng
macrozheng
Jun 15, 2021 · Backend Development

Mastering Redisson: Seamless Distributed Locks in Spring Boot

This tutorial explains what Redisson is, how it extends Redis with powerful distributed data structures and lock mechanisms, and provides step‑by‑step Spring Boot integration, code examples, and detailed testing of re‑entrant, read‑write, and semaphore locks.

ConcurrencyJavaRedis
0 likes · 15 min read
Mastering Redisson: Seamless Distributed Locks in Spring Boot
ITPUB
ITPUB
Jun 11, 2021 · Backend Development

Is Redis Distributed Lock Really Safe? Uncovering Redlock, Pitfalls, and Best Practices

This comprehensive guide explains why distributed locks are needed, walks through basic Redis lock implementations, reveals common dead‑lock and expiration issues, presents atomic solutions with SET EX NX and Lua scripts, evaluates the Redlock algorithm, examines expert debates, compares Zookeeper locks, and offers practical recommendations for safe usage.

Lua scriptZooKeeperdistributed lock
0 likes · 35 min read
Is Redis Distributed Lock Really Safe? Uncovering Redlock, Pitfalls, and Best Practices
Wukong Talks Architecture
Wukong Talks Architecture
Jun 9, 2021 · Backend Development

Inventory Deduction Strategies for Flash Sale (秒杀) Systems

This article examines three inventory‑deduction approaches for flash‑sale scenarios, discusses methods to mitigate malicious buyers, addresses payment‑failure due to insufficient stock, presents database‑level solutions to prevent overselling under high concurrency, and explores practical implementations using order‑time deduction, Redis caching, and rate limiting.

Flash SaleInventorydistributed lock
0 likes · 9 min read
Inventory Deduction Strategies for Flash Sale (秒杀) Systems
Top Architect
Top Architect
May 8, 2021 · Backend Development

Distributed Locks: Why They Are Needed, Required Conditions, and Three Implementation Approaches (Database, Redis, Zookeeper)

This article explains the necessity of distributed locks in multi‑node applications, outlines the essential properties a distributed lock must satisfy, and compares three common implementation methods—database‑based exclusive locks, Redis‑based locks, and Zookeeper‑based locks—highlighting their advantages, drawbacks, and usage patterns.

BackendRedis LockZookeeper lock
0 likes · 15 min read
Distributed Locks: Why They Are Needed, Required Conditions, and Three Implementation Approaches (Database, Redis, Zookeeper)
Youzan Coder
Youzan Coder
Apr 30, 2021 · Backend Development

Uncovering Hidden Flaws in a Distributed Lock Implementation: A Structured Code Review

This article examines the business context and collection workflow of a BOS‑integrated service, dissects the distributed lock logic and its execution sequence, and conducts a thorough structured code review that reveals logical, exception, non‑functional, and testability issues while offering concrete improvement recommendations.

BackendBest PracticesCode Review
0 likes · 8 min read
Uncovering Hidden Flaws in a Distributed Lock Implementation: A Structured Code Review
dbaplus Community
dbaplus Community
Apr 21, 2021 · Backend Development

21 Essential Redis Practices: Key Design, Pipelines, Locks, and Performance Tips

This guide compiles 21 practical Redis usage guidelines covering key naming conventions, value size limits, expiration strategies, batch operations, risky commands, distributed lock patterns, cache consistency, capacity planning, and common pitfalls like cache penetration, snowball, and hot‑key issues, helping developers and operators build reliable, high‑performance Redis deployments.

Best PracticesKey DesignPerformance
0 likes · 21 min read
21 Essential Redis Practices: Key Design, Pipelines, Locks, and Performance Tips
Architect's Tech Stack
Architect's Tech Stack
Apr 20, 2021 · Backend Development

Redis Distributed Lock Failure Analysis and Safer Lock Implementation for High‑Concurrency Seckill

This article examines a real‑world incident where a Redis‑based distributed lock caused a 100‑bottle oversell of a scarce product, analyzes the root causes such as lock expiration and non‑atomic stock checks, and presents safer lock and stock‑validation solutions using Lua scripts and atomic Redis operations.

ConcurrencyJavaPerformance
0 likes · 11 min read
Redis Distributed Lock Failure Analysis and Safer Lock Implementation for High‑Concurrency Seckill
Open Source Linux
Open Source Linux
Apr 16, 2021 · Operations

Mastering ZooKeeper: Core Concepts, Architecture, and Real‑World Use Cases

This comprehensive guide explains ZooKeeper’s role as a distributed coordination service, covering its consistency guarantees, Znode hierarchy, ZAB protocol, watcher mechanism, ACLs, server roles, data synchronization modes, deployment options, dynamic scaling, and typical use cases such as configuration management, service discovery, leader election, distributed locks and queues.

ACLDistributed CoordinationLeader Election
0 likes · 23 min read
Mastering ZooKeeper: Core Concepts, Architecture, and Real‑World Use Cases
macrozheng
macrozheng
Apr 1, 2021 · Backend Development

21 Essential Redis Usage Tips to Avoid Common Pitfalls

This article compiles 21 practical Redis guidelines covering key naming, value sizing, expiration strategies, batch operations, risky commands, distributed lock patterns, cache consistency, capacity planning, and configuration tips, helping developers and operators build reliable, high‑performance Redis‑backed systems.

CachingPerformanceRedis
0 likes · 25 min read
21 Essential Redis Usage Tips to Avoid Common Pitfalls
Code Ape Tech Column
Code Ape Tech Column
Mar 29, 2021 · Backend Development

Understanding Distributed Locks and Their Implementation with Redis and Zookeeper

Distributed locks ensure exclusive access across multiple servers in high-concurrency scenarios, and this article explains their necessity, illustrates problems with simple locks, and details practical implementations using Redis and Zookeeper, including lock acquisition, release, expiration handling, and avoiding deadlocks.

ConcurrencyRedisZooKeeper
0 likes · 13 min read
Understanding Distributed Locks and Their Implementation with Redis and Zookeeper
Java Captain
Java Captain
Mar 28, 2021 · Backend Development

Analysis and Solutions for Redis Distributed Lock Over‑selling in High‑Concurrency Seckill Scenario

This article examines a real‑world flash‑sale incident where Redis distributed locks failed, causing severe overselling, and presents root‑cause analysis, safer lock implementation with Lua scripts, atomic stock handling, refactored Java code, and deeper reflections on lock necessity and further optimizations.

ConcurrencyJavaLua
0 likes · 10 min read
Analysis and Solutions for Redis Distributed Lock Over‑selling in High‑Concurrency Seckill Scenario
360 Tech Engineering
360 Tech Engineering
Mar 15, 2021 · Backend Development

Distributed Lock Implementations with Redis, Etcd, and Zookeeper

This article explains the concept, application scenarios, and detailed implementations of distributed locks using Redis, Etcd, and Zookeeper, providing Java code examples, lock mechanisms, lease handling, watch features, and a comparative summary of their advantages and drawbacks.

distributed lock
0 likes · 14 min read
Distributed Lock Implementations with Redis, Etcd, and Zookeeper
360 Quality & Efficiency
360 Quality & Efficiency
Mar 12, 2021 · Backend Development

Distributed Lock Implementations with Redis, Etcd, and Zookeeper

This article explains the concept of distributed locks, outlines common application scenarios, and provides detailed Java implementations using Redis (including Redisson and RedLock), Etcd, and Zookeeper, complete with code examples and a comparative summary of their advantages and drawbacks.

BackendRedisdistributed lock
0 likes · 14 min read
Distributed Lock Implementations with Redis, Etcd, and Zookeeper
360 Smart Cloud
360 Smart Cloud
Feb 25, 2021 · Backend Development

Understanding Distributed Locks: Concepts, System Classification, and Implementations with Redis and etcd/Zookeeper

This article explains the fundamentals of distributed locks, compares lock implementations based on asynchronous replication and Paxos protocols, and provides practical Redis and etcd/Zookeeper examples—including exclusive and shared lock mechanisms, code snippets, and usage considerations for reliability and safety.

BackendConcurrencyZooKeeper
0 likes · 9 min read
Understanding Distributed Locks: Concepts, System Classification, and Implementations with Redis and etcd/Zookeeper
Selected Java Interview Questions
Selected Java Interview Questions
Feb 4, 2021 · Backend Development

Understanding Thread Locks, Process Locks, and Distributed Locks: Concepts and Implementation with Redis and Zookeeper

This article explains the differences between thread, process, and distributed locks, describes how distributed locks are implemented using third‑party storage such as Redis and Zookeeper, and discusses practical scenarios, advantages, and design considerations for using distributed locks in high‑concurrency systems.

distributed lock
0 likes · 10 min read
Understanding Thread Locks, Process Locks, and Distributed Locks: Concepts and Implementation with Redis and Zookeeper
Programmer DD
Programmer DD
Dec 29, 2020 · Backend Development

Mastering Locks: Optimistic, Pessimistic, and Distributed Strategies for High-Concurrency Systems

This article explains the different lock types—pessimistic, optimistic, and distributed—covers their use cases, compares their advantages and drawbacks, and provides concrete code examples and four practical solutions for handling high‑concurrency deduction scenarios such as inventory or balance reduction.

JavaOptimistic LockPessimistic Lock
0 likes · 13 min read
Mastering Locks: Optimistic, Pessimistic, and Distributed Strategies for High-Concurrency Systems
Java Interview Crash Guide
Java Interview Crash Guide
Dec 29, 2020 · Backend Development

How Distributed Locks Prevent Chaos in Massive Red‑Packet Systems

This article explains why traditional locks fail under massive concurrent traffic, how distributed locks coordinate multiple servers to ensure correct total payouts, and compares Redis and Zookeeper implementations, highlighting their mechanisms, pitfalls, and practical considerations for large‑scale systems.

ConcurrencyZooKeeperdistributed lock
0 likes · 13 min read
How Distributed Locks Prevent Chaos in Massive Red‑Packet Systems
Architecture Digest
Architecture Digest
Dec 27, 2020 · Backend Development

Implementing Distributed Locks with Redis, Redisson, and Zookeeper

This article explains the concepts and practical implementations of distributed locks, comparing local JVM locks with Redis‑based locks (including atomic SETNX/SETEX and Lua scripts), Redisson's high‑level API, and Zookeeper's sequential‑node approach, and provides Java code examples for each solution.

BackendJavaZooKeeper
0 likes · 13 min read
Implementing Distributed Locks with Redis, Redisson, and Zookeeper
Laravel Tech Community
Laravel Tech Community
Dec 15, 2020 · Backend Development

lock4j-spring-boot-starter 2.1.0 Release Overview

lock4j-spring-boot-starter is a Spring Boot distributed lock library that provides simple yet powerful locking capabilities with support for Redisson, RedisTemplate, and Zookeeper, and the 2.1.0 release adds global configuration, executor enhancements, default priority ordering, and both declarative and programmatic usage options.

BackendJavaRedis
0 likes · 2 min read
lock4j-spring-boot-starter 2.1.0 Release Overview
Programmer DD
Programmer DD
Dec 6, 2020 · Databases

Master Redis Interview: Persistence, Caching Strategies, Clustering & More

This comprehensive guide covers essential Redis interview topics, including persistence mechanisms (RDB and AOF), cache challenges such as avalanche, penetration and pre‑warming, data types and their use cases, internal structures, eviction policies, single‑thread performance, clustering solutions, distributed locking, transactions, and best practices for high‑traffic environments.

CachingClusteringPerformance
0 likes · 25 min read
Master Redis Interview: Persistence, Caching Strategies, Clustering & More
dbaplus Community
dbaplus Community
Dec 3, 2020 · Backend Development

Boosting Distributed Lock Throughput for Thousands of Orders per Second

Learn how to overcome the concurrency bottleneck of traditional distributed locks in high‑traffic e‑commerce scenarios by applying segment‑based locking and other optimization techniques, enabling thousands of orders per second while preventing inventory overselling.

High Concurrencybackend optimizationdistributed lock
0 likes · 11 min read
Boosting Distributed Lock Throughput for Thousands of Orders per Second
Code Ape Tech Column
Code Ape Tech Column
Nov 30, 2020 · Backend Development

Master Redis: Persistence, Caching Pitfalls, Clustering & Performance Tips

This article provides a comprehensive guide to Redis for interview preparation, covering persistence mechanisms, common caching challenges such as avalanche and penetration, data types and their use cases, internal structures, expiration policies, single‑threaded performance, clustering options, distributed locking, and best‑practice solutions.

CachingClusteringData Types
0 likes · 27 min read
Master Redis: Persistence, Caching Pitfalls, Clustering & Performance Tips
MaGe Linux Operations
MaGe Linux Operations
Nov 15, 2020 · Backend Development

Why Distributed Locks Matter: Redis vs Zookeeper Explained

This article examines the stock‑oversell problem in high‑concurrency e‑commerce systems, explains why native JVM locks fail in multi‑machine deployments, and compares practical distributed‑lock solutions using Redis (including RedLock and Redisson) and Zookeeper (with Curator), highlighting their advantages, drawbacks, and selection guidelines.

BackendConcurrencydistributed lock
0 likes · 18 min read
Why Distributed Locks Matter: Redis vs Zookeeper Explained
Java Backend Technology
Java Backend Technology
Nov 12, 2020 · Backend Development

Why Java Locks Fail in Distributed Systems and How Redis & Zookeeper Fix Them

Java’s built‑in synchronization mechanisms work only within a single JVM, leading to inventory‑oversell problems when scaling an e‑commerce service across multiple machines, so developers turn to distributed lock solutions such as Redis (with RedLock or Redisson) and Zookeeper (using ordered and temporary nodes) to ensure global mutual exclusion.

CuratorJava concurrencyZooKeeper
0 likes · 19 min read
Why Java Locks Fail in Distributed Systems and How Redis & Zookeeper Fix Them
ITPUB
ITPUB
Nov 9, 2020 · Backend Development

Why Distributed Locks Matter: Solving Inventory Oversell with Redis and Zookeeper

The article explains how a single‑machine Java lock can cause inventory oversell in a distributed e‑commerce system, introduces the concept of a global distributed lock, and compares practical implementations using Redis (including RedLock and Redisson) and Zookeeper (with Curator), highlighting their trade‑offs and selection guidelines.

RedisZooKeeperdistributed lock
0 likes · 17 min read
Why Distributed Locks Matter: Solving Inventory Oversell with Redis and Zookeeper
Java Captain
Java Captain
Nov 7, 2020 · Backend Development

Why Use Distributed Locks? Implementations with Redis and Zookeeper

The article explains the stock‑oversell problem in a single‑machine e‑commerce system, shows why native Java locks fail in multi‑node deployments, and then details practical distributed‑lock solutions using Redis (including SET NX PX, Lua‑based release, RedLock algorithm and Redisson) and Zookeeper (ephemeral sequential nodes and Curator), before comparing their advantages, drawbacks, and offering selection guidance.

ConcurrencyZooKeeperdistributed lock
0 likes · 17 min read
Why Use Distributed Locks? Implementations with Redis and Zookeeper
Java Architect Essentials
Java Architect Essentials
Oct 2, 2020 · Backend Development

Handling Cache Penetration, Breakdown, and Avalanche in Backend Systems

This article explains the three major cache issues—penetration, breakdown, and avalanche—describes why they occur in high‑traffic systems, and presents four practical mitigation strategies including Bloom filters, short‑lived empty caches, distributed mutex locks with Redis or Memcache, and resource isolation with Hystrix.

BackendRediscache
0 likes · 9 min read
Handling Cache Penetration, Breakdown, and Avalanche in Backend Systems
Top Architect
Top Architect
Sep 29, 2020 · Backend Development

Implementing Distributed Locks with Redisson in Spring Boot

This article demonstrates how to integrate Redisson with Spring Boot to create Redis‑based distributed locks, provides Maven dependency configuration, shows a Spring @Configuration class for Redisson, offers a utility wrapper for lock operations, and includes a REST controller with a concurrent test to illustrate correct locking behavior versus no‑lock scenarios.

JavaSpring Bootdistributed lock
0 likes · 8 min read
Implementing Distributed Locks with Redisson in Spring Boot
vivo Internet Technology
vivo Internet Technology
Sep 23, 2020 · Databases

Redis Caching: Use Cases, Best Practices, Common Pitfalls, and Monitoring

The article explains how Redis caching boosts high‑concurrency applications by outlining common use cases such as counters, session storage, rate limiting, leaderboards and distributed locks, then details best‑practice guidelines, typical pitfalls like TTL overwrites and cache stampedes, and essential monitoring techniques for performance and reliability.

PerformanceRedisdistributed lock
0 likes · 13 min read
Redis Caching: Use Cases, Best Practices, Common Pitfalls, and Monitoring
Selected Java Interview Questions
Selected Java Interview Questions
Sep 22, 2020 · Backend Development

Understanding Distributed Locks: Redis vs Zookeeper Implementations

This article explains why native Java locks fail in multi‑node deployments, introduces the concept of a distributed lock, and compares two popular implementations—Redis (including RedLock and Redisson) and Zookeeper (with Curator)—detailing their mechanisms, code examples, advantages, drawbacks, and practical selection guidance.

RedisZooKeeperdistributed lock
0 likes · 18 min read
Understanding Distributed Locks: Redis vs Zookeeper Implementations
Programmer DD
Programmer DD
Sep 8, 2020 · Backend Development

Why Redis Distributed Locks Fail in Flash Sales and How to Fix Them

This article examines a real flash‑sale incident where Redis distributed locks expired, causing overselling, analyzes the root causes such as lock safety and non‑atomic stock checks, and presents safer lock implementations, atomic stock operations, and architectural reflections to prevent future failures.

PerformanceRedisSpringBoot
0 likes · 11 min read
Why Redis Distributed Locks Fail in Flash Sales and How to Fix Them
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 4, 2020 · Databases

Comprehensive Guide to Redis Data Structures, Persistence, Transactions, Clustering, and Applications

This article provides an in‑depth technical overview of Redis, covering its core data structures, memory allocation strategies, eviction policies, persistence mechanisms (RDB and AOF), transaction model, sentinel and cluster architectures, Pub/Sub messaging, and multiple approaches to implementing distributed locks.

ClusteringData StructuresPersistence
0 likes · 89 min read
Comprehensive Guide to Redis Data Structures, Persistence, Transactions, Clustering, and Applications
Sohu Tech Products
Sohu Tech Products
Sep 2, 2020 · Backend Development

Implementing Distributed Locks with Redis and Redisson: Abstraction, Auto-Release, and Fault Tolerance

This article explains how to use Redis and Redisson for distributed locking, introduces an abstract DistributedLock interface for flexible implementations, demonstrates automatic lock release with functional callbacks, and discusses fallback strategies and monitoring to ensure reliability in backend systems.

JavaRedisdistributed lock
0 likes · 5 min read
Implementing Distributed Locks with Redis and Redisson: Abstraction, Auto-Release, and Fault Tolerance
Programmer DD
Programmer DD
Aug 27, 2020 · Backend Development

Unlocking Redisson: How Distributed Locks Work Under the Hood

This article walks through configuring Redisson with Maven, demonstrates a simple distributed lock example using Sentinel, lists the Redis commands and Lua script semantics involved, and provides a detailed source‑code analysis of the RLock interface, tryLock, unlock, and forceUnlock methods.

LuaMavenRedis
0 likes · 13 min read
Unlocking Redisson: How Distributed Locks Work Under the Hood
Top Architect
Top Architect
Aug 8, 2020 · Backend Development

Analysis and Solutions for Redis Distributed Lock Over‑sell Incident in High‑Concurrency Seckill

This article examines a real-world over‑sell incident caused by an unsafe Redis distributed lock in a high‑traffic seckill service, analyzes the root causes such as lock expiration and non‑atomic stock checks, and presents safer lock implementations, atomic stock operations, and refactored code to prevent future overselling.

AtomicityJavaPerformance
0 likes · 11 min read
Analysis and Solutions for Redis Distributed Lock Over‑sell Incident in High‑Concurrency Seckill
MaGe Linux Operations
MaGe Linux Operations
Jul 29, 2020 · Backend Development

How to Build Safe Distributed Locks with Redis and Redisson

This article explains why simple SETNX/EXPIRE commands can cause deadlocks, shows how to achieve atomic lock operations with Lua scripts or the Redis SET command, and demonstrates how to use the Redisson library for re‑entrant, auto‑renewing distributed locks in Java.

Lua scriptRedisdistributed lock
0 likes · 8 min read
How to Build Safe Distributed Locks with Redis and Redisson
58 Tech
58 Tech
Jul 27, 2020 · Databases

Implementing Distributed Locks with Databases, Redis, and Zookeeper

This article explains how to build distributed locks using three different technologies—database tables, Redis, and Zookeeper—detailing their implementation steps, code examples, advantages, drawbacks, and practical considerations for choosing the right solution in real‑world scenarios.

ConcurrencyZooKeeperdatabase
0 likes · 17 min read
Implementing Distributed Locks with Databases, Redis, and Zookeeper
Selected Java Interview Questions
Selected Java Interview Questions
Jul 16, 2020 · Backend Development

Understanding Thread Locks, Process Locks, and Distributed Locks in Distributed Systems

The article explains the differences between thread, process, and distributed locks, describes how distributed locks are implemented using third‑party storage like Redis or Zookeeper, and discusses their practical use cases, advantages, and design considerations in high‑concurrency backend applications.

ZooKeeperbackend developmentdistributed lock
0 likes · 11 min read
Understanding Thread Locks, Process Locks, and Distributed Locks in Distributed Systems
Laravel Tech Community
Laravel Tech Community
Jul 15, 2020 · Databases

Comprehensive Redis Interview Questions and Answers

This article provides a comprehensive overview of Redis, covering its definition, advantages over memcached, supported data types, memory consumption, eviction policies, clustering options, persistence mechanisms, distributed lock implementations, cache penetration and avalanche solutions, and best-use scenarios compared to other caching systems.

ClusteringPersistenceRedis
0 likes · 26 min read
Comprehensive Redis Interview Questions and Answers
Qunar Tech Salon
Qunar Tech Salon
Jul 14, 2020 · Backend Development

Distributed Lock Mechanisms and Their Redis Implementations

This article explains the concept of distributed locks, compares various implementation approaches such as Memcached, Zookeeper, Chubby, and Redis, and details single‑node and multi‑node Redis lock designs—including SETNX, SET with NX/EX options, Redisson, and the Redlock algorithm—while highlighting their advantages, pitfalls, and best‑practice recommendations.

ConcurrencyRedisdatabase
0 likes · 14 min read
Distributed Lock Mechanisms and Their Redis Implementations
Top Architect
Top Architect
Jul 13, 2020 · Databases

Understanding Redis Distributed Locks: setnx, Redisson, and RedLock

This article explains the fundamentals and pitfalls of using Redis for distributed locking, covering the setnx command, the SET command with NX and PX options, Lua‑based lock scripts, Redisson’s lock implementations, and the RedLock algorithm, along with practical code examples.

LuaRedisdistributed lock
0 likes · 12 min read
Understanding Redis Distributed Locks: setnx, Redisson, and RedLock
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 5, 2020 · Backend Development

How Alibaba Cloud Implements Reliable Distributed Locks for Shared Resources

Distributed locks ensure exclusive access to shared resources across multiple machines, and this article explains their evolution from single-machine locks, classifies system designs, and details Alibaba Cloud Storage’s practical implementation, covering strict mutual exclusion, availability, and lock-switching efficiency with real-world examples.

Alibaba CloudStorageavailability
0 likes · 13 min read
How Alibaba Cloud Implements Reliable Distributed Locks for Shared Resources
Architecture Digest
Architecture Digest
Jun 16, 2020 · Backend Development

Why Use Distributed Locks? Implementation with Redis, Redisson, and Zookeeper

The article explains the inventory oversell problem in distributed e‑commerce systems, why native JVM locks fail across multiple machines, and presents practical implementations of distributed locks using Redis (including RedLock and Redisson) and Zookeeper (with Curator), comparing their advantages and drawbacks.

Java concurrencydistributed lockdistributed systems
0 likes · 17 min read
Why Use Distributed Locks? Implementation with Redis, Redisson, and Zookeeper
Programmer DD
Programmer DD
Jun 14, 2020 · Backend Development

How Distributed Locks Prevent Over‑Allocation in Massive Red‑Packet Systems

This article explains why traditional locks fail in high‑concurrency scenarios like large‑scale red‑packet distribution, and demonstrates how distributed locking mechanisms using Redis and Zookeeper ensure correct total amounts while avoiding deadlocks and thundering‑herd problems.

RedisZooKeeperdistributed lock
0 likes · 14 min read
How Distributed Locks Prevent Over‑Allocation in Massive Red‑Packet Systems
Architecture Digest
Architecture Digest
Jun 13, 2020 · Cloud Native

Using etcd and jetcd for Master‑Standby Service Coordination in Java

This article explains what etcd is, describes a master‑standby high‑availability scenario, and provides a step‑by‑step Java implementation with jetcd, including Maven dependency, client initialization, lease and lock APIs, and complete test cases that demonstrate automatic failover.

Javadistributed locketcd
0 likes · 9 min read
Using etcd and jetcd for Master‑Standby Service Coordination in Java
Architect's Tech Stack
Architect's Tech Stack
Jun 11, 2020 · Backend Development

Understanding Redis Distributed Locks: setnx, RedLock, and Redisson

This article explains how Redis can be used for distributed locking, covering the setnx command, the SET command with NX and PX options, common pitfalls, Lua‑based atomic unlock scripts, the Redisson client, and the RedLock algorithm for achieving reliable locks across multiple nodes.

Lua scriptingRedisbackend development
0 likes · 10 min read
Understanding Redis Distributed Locks: setnx, RedLock, and Redisson
Java Captain
Java Captain
May 25, 2020 · Backend Development

Implementing Distributed Locks with Redisson in Spring Boot

This article demonstrates how to integrate Redisson with Spring Boot to create Redis‑based distributed locks, covering Maven dependencies, YAML configuration, a Redisson configuration class, utility methods for locking and unlocking, and a sample controller that simulates concurrent access to verify lock behavior.

JavaRedisSpring Boot
0 likes · 8 min read
Implementing Distributed Locks with Redisson in Spring Boot
Open Source Linux
Open Source Linux
May 4, 2020 · Databases

Redis Deep Dive: Core Concepts, Performance, Persistence, and Scaling Strategies

This comprehensive guide explains what Redis is, its advantages and drawbacks, why it excels as a high‑performance cache, the supported data structures, persistence mechanisms, memory eviction policies, threading model, transaction handling, clustering and sharding options, distributed locking, common cache pitfalls, and useful tooling for Java developers.

CachingIn-Memory DatabasePersistence
0 likes · 45 min read
Redis Deep Dive: Core Concepts, Performance, Persistence, and Scaling Strategies
21CTO
21CTO
May 2, 2020 · Backend Development

Master Distributed Caching, Rate Limiting, Locks & Idempotency with Alibaba Tools

This article introduces Alibaba's distributed‑tools component, explaining how to configure Redis/Tair cache, implement fixed‑window rate limiting, use a high‑performance distributed lock template, and apply idempotency mechanisms with annotations and templates to ensure reliable microservice operations.

CachingRate LimitingSpringBoot
0 likes · 15 min read
Master Distributed Caching, Rate Limiting, Locks & Idempotency with Alibaba Tools
dbaplus Community
dbaplus Community
Apr 27, 2020 · Backend Development

Why Your Redis Distributed Lock May Fail and How to Fix It

This article examines common failure scenarios of Redis‑based distributed locks, compares a simple lock implementation with the Redlock algorithm, and provides practical solutions for single‑point failures, lock expiration issues, clock drift, and high‑concurrency pitfalls.

ConcurrencyJavaLock Pitfalls
0 likes · 18 min read
Why Your Redis Distributed Lock May Fail and How to Fix It
Java Backend Technology
Java Backend Technology
Mar 7, 2020 · Backend Development

Mastering ZooKeeper: Core Concepts, Distributed Locks, and Cluster Management

This article explains ZooKeeper's role as a distributed coordination service, covering its architecture, znode types, watch mechanism, configuration management, distributed locking, queue handling, data replication, leader election, and synchronization processes for building reliable backend systems.

Coordination ServiceZooKeepercluster-management
0 likes · 18 min read
Mastering ZooKeeper: Core Concepts, Distributed Locks, and Cluster Management
ITPUB
ITPUB
Mar 2, 2020 · Big Data

Mastering ZooKeeper: Core Concepts and Real-World Big Data Applications

This article explains ZooKeeper’s architecture, key concepts such as roles, sessions, ZNodes, versioning, ACLs, and watchers, and demonstrates how it powers essential big‑data components like Hadoop’s ResourceManager and HBase’s master election, naming service, and distributed locking.

Distributed CoordinationHBaseHadoop
0 likes · 23 min read
Mastering ZooKeeper: Core Concepts and Real-World Big Data Applications
Java Interview Crash Guide
Java Interview Crash Guide
Feb 12, 2020 · Backend Development

How Distributed Locks Prevent Chaos in Massive Red‑Packet Systems

Distributed locks ensure that, across hundreds of servers handling millions of concurrent red‑packet requests, only one instance updates the shared total at a time, preventing inconsistencies and deadlocks, with implementations ranging from Java synchronized blocks to Redis SETNX and Zookeeper Znode mechanisms.

ConcurrencyZooKeeperdistributed lock
0 likes · 14 min read
How Distributed Locks Prevent Chaos in Massive Red‑Packet Systems
FunTester
FunTester
Feb 12, 2020 · Backend Development

How to Stress-Test a VIP Payment Callback API with Distributed Locks

This article walks through a complete performance‑testing setup for a VIP purchase callback API, detailing the request flow, distributed‑lock handling with Redis, parameter generation using AtomicInteger, Java implementation, and pitfalls to ensure accurate, high‑concurrency testing.

APIBackendConcurrency
0 likes · 6 min read
How to Stress-Test a VIP Payment Callback API with Distributed Locks
Alibaba Cloud Native
Alibaba Cloud Native
Jan 22, 2020 · Backend Development

Mastering Microservices: RPC, Service Discovery, Config, Scheduling & More

This comprehensive guide explains the benefits of microservices and walks through core building blocks such as RPC, service discovery, configuration management, task scheduling, distributed locking, unified monitoring, caching strategies, message queues, distributed transactions, CAP theory, seckill handling, Docker isolation, and modern CI/CD deployment pipelines.

Backendconfiguration managementdistributed lock
0 likes · 24 min read
Mastering Microservices: RPC, Service Discovery, Config, Scheduling & More
Senior Brother's Insights
Senior Brother's Insights
Dec 25, 2019 · Backend Development

Ensuring Idempotency in Distributed Systems: Strategies and Best Practices

The article explains why idempotent operations are essential in high‑traffic systems, defines idempotency, and presents a comprehensive set of techniques—including unique indexes, token validation, pessimistic and optimistic locking, distributed locks, select‑plus‑insert patterns, state‑machine design, and API safeguards—to guarantee consistent outcomes even under repeated requests.

Optimistic Lockdatabasedistributed lock
0 likes · 9 min read
Ensuring Idempotency in Distributed Systems: Strategies and Best Practices
Architect's Tech Stack
Architect's Tech Stack
Dec 24, 2019 · Operations

Application and Principles of Zookeeper in Microservices

This article explains Zookeeper's core features—such as its tree‑like directory, persistent and ephemeral nodes, sequential ordering, and watcher mechanism—and demonstrates how these capabilities enable distributed locks and service registration/discovery within microservice architectures.

Distributed CoordinationZooKeeperdistributed lock
0 likes · 6 min read
Application and Principles of Zookeeper in Microservices
Programmer DD
Programmer DD
Dec 10, 2019 · Databases

Mastering Redis: From Caching Basics to Distributed Locks and Cluster Scaling

This comprehensive guide explores Redis caching fundamentals, data structures, key‑search techniques, distributed lock implementation, asynchronous queues, persistence options (RDB, AOF, hybrid), pipeline usage, replication, Sentinel monitoring, and cluster sharding with consistent hashing to help developers build high‑performance, reliable systems.

CachingPersistenceRedis
0 likes · 20 min read
Mastering Redis: From Caching Basics to Distributed Locks and Cluster Scaling