BestHub
Sign in
Tagged articles

idempotency

273 articles · Page 3 of 3
Su San Talks Tech
Su San Talks Tech
Mar 28, 2021 · Backend Development

How to Ensure API Idempotency: 8 Proven Strategies for Backend Systems

Ensuring API idempotency prevents duplicate data caused by repeated requests, timeouts, or message reprocessing, and can be achieved through techniques such as pre‑insert checks, pessimistic and optimistic locking, unique indexes, anti‑duplicate tables, state‑machine checks, distributed locks, and token‑based validation.

Lockingdistributed-systemsidempotency
0 likes · 13 min read
How to Ensure API Idempotency: 8 Proven Strategies for Backend Systems
Kuaishou Tech
Kuaishou Tech
Mar 25, 2021 · Backend Development

Designing a High‑Availability Cache Consistency Solution for the Creator Red Packet System

This article explains how the creator red‑packet feature was engineered to guarantee idempotent, fault‑tolerant, and high‑throughput red‑packet claims by using multi‑level caching, empty placeholders, binlog‑driven synchronization, active cache invalidation, ordered Kafka consumption, and fallback strategies to resolve cache‑DB consistency issues.

BinlogCache consistencyRedis
0 likes · 11 min read
Designing a High‑Availability Cache Consistency Solution for the Creator Red Packet System
ITPUB
ITPUB
Mar 25, 2021 · Backend Development

Why a TCC Framework Must Own the Spring TransactionManager

This article examines the challenges of building a generic TCC distributed‑transaction framework on Spring, explaining why every TCC service must participate in RM‑local transactions, why the framework should intercept the Spring TransactionManager, how to handle fault recovery, idempotency of Confirm/Cancel, and the pitfalls of relying on Cancel for rollback, concluding with practical recommendations.

SpringTCCTransactionManager
0 likes · 18 min read
Why a TCC Framework Must Own the Spring TransactionManager
Java Architect Essentials
Java Architect Essentials
Feb 26, 2021 · Backend Development

How to Gracefully Prevent Duplicate Requests on the Server Side

This article explains why duplicate requests—especially write operations—can cause serious issues, outlines common causes such as replay attacks and client retries, and provides a comprehensive server‑side solution using unique request IDs, Redis, and MD5‑based parameter deduplication with Java code examples.

JavaMD5Redis
0 likes · 9 min read
How to Gracefully Prevent Duplicate Requests on the Server Side
Top Architect
Top Architect
Feb 15, 2021 · Backend Development

Implementing API Idempotency in SpringBoot Using Redis Token Mechanism

This tutorial explains the concept of idempotency, why it is needed for reliable APIs, the impact on system design, and provides four implementation strategies—including a detailed SpringBoot example that uses Redis tokens, Lua scripts, and unit tests—to ensure that repeated requests produce the same result without side effects.

JavaRESTful APIRedis
0 likes · 18 min read
Implementing API Idempotency in SpringBoot Using Redis Token Mechanism
21CTO
21CTO
Feb 14, 2021 · Backend Development

How to Gracefully Prevent Duplicate Requests with Redis and Java

This article explains why duplicate requests—especially those that modify data—can be dangerous, outlines common causes, and provides a comprehensive server‑side solution using unique request IDs, parameter hashing, and a Java utility class with Redis to reliably deduplicate incoming calls.

DeduplicationJavaRedis
0 likes · 8 min read
How to Gracefully Prevent Duplicate Requests with Redis and Java
Code Ape Tech Column
Code Ape Tech Column
Feb 4, 2021 · Backend Development

Implementing API Idempotency in SpringBoot Using Token and Redis

This article explains the concept of idempotency, why it is needed for HTTP interfaces, its impact on system design, and presents four practical backend solutions—including database primary keys, optimistic locking, anti‑repeat tokens, and downstream sequence numbers—followed by a complete SpringBoot example with Maven dependencies, Redis configuration, token utility code, controller, application starter, and test cases.

JavaRESTful APIToken
0 likes · 20 min read
Implementing API Idempotency in SpringBoot Using Token and Redis
Code Ape Tech Column
Code Ape Tech Column
Jan 25, 2021 · Backend Development

Ensuring Zero Message Loss in RabbitMQ: Persistence, Confirm, and Idempotent Strategies

This article examines how to guarantee reliable message delivery in RabbitMQ by using durable queues, the confirm callback mechanism, pre‑persisting messages with Redis or a database, scheduled compensation tasks, and idempotent processing techniques such as optimistic locking and unique‑ID fingerprinting.

Confirm CallbackMessage QueuePersistence
0 likes · 11 min read
Ensuring Zero Message Loss in RabbitMQ: Persistence, Confirm, and Idempotent Strategies
Selected Java Interview Questions
Selected Java Interview Questions
Jan 22, 2021 · Backend Development

Ensuring Reliable Message Delivery with RabbitMQ: Persistence, Confirm Mechanism, and Idempotency Strategies

This article explains how to guarantee reliable message delivery in RabbitMQ by using durable queues, the confirm mechanism, and supplemental strategies such as pre‑persisting messages to Redis, scheduled compensation tasks, and idempotent consumer design to prevent duplicate processing.

confirmdistributed-systemsidempotency
0 likes · 9 min read
Ensuring Reliable Message Delivery with RabbitMQ: Persistence, Confirm Mechanism, and Idempotency Strategies
Java Interview Crash Guide
Java Interview Crash Guide
Jan 8, 2021 · Backend Development

Mastering API Idempotency: Strategies, Code Samples, and Best Practices

Idempotency ensures that repeated API calls produce the same effect as a single call, preventing duplicate submissions, token misuse, and inconsistent data; this guide explains the concept, its importance, HTTP definitions, impact on systems, and presents four practical implementation methods—unique keys, optimistic locking, token‑based guards, and sequence numbers—with full SpringBoot and Redis code examples.

APIRESTRedis
0 likes · 20 min read
Mastering API Idempotency: Strategies, Code Samples, and Best Practices
Xianyu Technology
Xianyu Technology
Dec 15, 2020 · Backend Development

How Xianyu Built the ‘Resale Lottery’ and ‘Money Tree’ Marketing Engines

This article examines Xianyu's two promotional features—Resale Lottery and Money Tree—detailing their gameplay, underlying business models, and the backend technical solutions such as event collection, idempotent reward accounting, concurrency control, fatigue management, and distributed locking.

Backend DevelopmentConcurrency ControlEvent Processing
0 likes · 11 min read
How Xianyu Built the ‘Resale Lottery’ and ‘Money Tree’ Marketing Engines
Senior Brother's Insights
Senior Brother's Insights
Nov 30, 2020 · Backend Development

Ensuring Idempotency in Distributed Systems: Strategies and Code Examples

The article explains why idempotent operations are essential in backend and financial systems, describes the mathematical concept, and presents practical techniques such as unique indexes, token validation, pessimistic and optimistic locking, distributed locks, state‑machine design, and API patterns with concrete SQL examples.

databaseidempotencyoptimistic lock
0 likes · 8 min read
Ensuring Idempotency in Distributed Systems: Strategies and Code Examples
Java Architecture Diary
Java Architecture Diary
Nov 10, 2020 · Backend Development

Ensuring Idempotency in Spring Boot: Token-Based Approach with Redis

This article explains the concept of idempotency, its importance in distributed systems, and demonstrates a practical implementation in Spring Boot using a token-based annotation, Redis configuration, and sample code, along with testing results that show only one successful response among concurrent requests.

idempotencyspring-boot
0 likes · 6 min read
Ensuring Idempotency in Spring Boot: Token-Based Approach with Redis
Top Architect
Top Architect
Oct 29, 2020 · Backend Development

Implementing API Idempotency in Spring Boot Using Redis and Token Mechanism

This article explains the concept of API idempotency, presents common solutions such as unique indexes, token mechanisms, and distributed locks, and provides a complete Spring Boot implementation using Redis to generate, store, and validate tokens via custom annotations, interceptors, and service classes, including testing and performance verification.

APIJavaSpring Boot
0 likes · 14 min read
Implementing API Idempotency in Spring Boot Using Redis and Token Mechanism
Tuhu Marketing Technology Team
Tuhu Marketing Technology Team
Oct 10, 2020 · Backend Development

Ensuring Idempotency in Distributed Systems: Strategies and Code Samples

This article explains the concept of idempotency, examines common failure scenarios such as duplicate order creation, coupon redemption, and inventory deduction, and presents practical solutions—including unique identifiers, locking, database constraints, and state‑machine approaches—accompanied by concrete SQL and pseudo‑code examples.

Backend DevelopmentCode examplesLocking
0 likes · 12 min read
Ensuring Idempotency in Distributed Systems: Strategies and Code Samples
Architect's Tech Stack
Architect's Tech Stack
Sep 30, 2020 · Backend Development

Implementing API Idempotency with Redis Token Mechanism in Spring Boot

This article explains the concept of API idempotency, reviews common solutions, and provides a complete Spring Boot implementation using a Redis‑based token mechanism, custom @ApiIdempotent annotation, interceptor, and supporting services, along with testing and important concurrency considerations.

APIRedisSpring Boot
0 likes · 14 min read
Implementing API Idempotency with Redis Token Mechanism in Spring Boot
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 20, 2020 · Backend Development

General Idempotent Implementation for Backend Services

This article explains the concepts, challenges, and practical implementations of idempotency in backend systems, covering simple database‑record checks, concurrency handling with locks, a reusable idempotent component with multi‑level storage, annotation support, automatic key generation, and sample Java code.

Annotationidempotency
0 likes · 11 min read
General Idempotent Implementation for Backend Services
dbaplus Community
dbaplus Community
Sep 16, 2020 · Backend Development

How to Solve Distributed Transactions, Idempotency, and Async Messaging in Microservices

This article shares practical strategies for handling distributed transactions, idempotent operations, and asynchronous message ordering in microservice architectures, covering pitfalls of RPC inside transactions, compensation patterns, local message tables, and state‑driven messaging to achieve reliable consistency without sacrificing performance.

CompensationLocal Message Tableidempotency
0 likes · 25 min read
How to Solve Distributed Transactions, Idempotency, and Async Messaging in Microservices
Java Backend Technology
Java Backend Technology
Sep 13, 2020 · Backend Development

How to Build a Robust Idempotent Framework for Distributed Systems

This article explains why idempotency is essential, presents simple database‑based and concurrency‑safe implementations, and then details a generic, annotation‑driven idempotent framework with multi‑level storage, code examples, and deployment guidelines for Java backend services.

Annotationbackenddistributed systems
0 likes · 12 min read
How to Build a Robust Idempotent Framework for Distributed Systems
Top Architect
Top Architect
Aug 16, 2020 · Backend Development

Implementing API Idempotency in Spring Boot Using Redis and Token Mechanism

This article explains how to achieve API idempotency in a Spring Boot application by generating unique tokens, storing them in Redis, and using a custom @ApiIdempotent annotation with an interceptor to prevent duplicate requests, including code examples, configuration, and testing procedures.

APIJavaSpring Boot
0 likes · 14 min read
Implementing API Idempotency in Spring Boot Using Redis and Token Mechanism
macrozheng
macrozheng
Jul 20, 2020 · Backend Development

How to Prevent Duplicate Submissions in Java: Simple Backend Solutions

This article explores practical methods to prevent duplicate submissions in Java applications, starting with a simple front‑end button disabling technique and progressing through several backend strategies—including HashMap, fixed‑size array, double‑checked locking, and Apache Commons LRUMap—complete with code samples and performance considerations.

JavaLRUMapSpring Boot
0 likes · 17 min read
How to Prevent Duplicate Submissions in Java: Simple Backend Solutions
Programmer DD
Programmer DD
Jul 11, 2020 · Backend Development

How to Build a Reliable Email Service with RabbitMQ and Spring Boot

This article walks through creating a robust email‑sending system using Spring Boot and RabbitMQ, covering message confirmation, consumer idempotency, retry mechanisms, scheduled re‑delivery, and detailed code examples to ensure reliable delivery even under failure conditions.

EmailRabbitMQSpring Boot
0 likes · 16 min read
How to Build a Reliable Email Service with RabbitMQ and Spring Boot
Top Architect
Top Architect
Jun 8, 2020 · Backend Development

Ensuring Idempotency with Unique IDs: UUID, Snowflake, and Distributed ID Generation

The article explains why idempotency is essential for reliable services, describes how unique identifiers such as UUIDs, Snowflake IDs, and database‑generated keys can be used to achieve it, and offers practical guidance on shared storage, avoiding unnecessary queries, and handling duplicate requests in distributed systems.

SnowflakeUUIDUnique ID
0 likes · 8 min read
Ensuring Idempotency with Unique IDs: UUID, Snowflake, and Distributed ID Generation
Architecture Digest
Architecture Digest
May 11, 2020 · Backend Development

Ensuring Idempotency in Distributed Systems: Unique ID Generation Strategies

The article explains why idempotency is essential for reliable service calls, discusses using unique identifiers such as UUIDs and Snowflake algorithms, compares centralized and client‑side ID generation, and offers practical storage and query‑optimisation techniques to prevent duplicate orders and resource waste.

SnowflakeUUIDUnique ID
0 likes · 6 min read
Ensuring Idempotency in Distributed Systems: Unique ID Generation 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.

CachingDistributed Lockidempotency
0 likes · 15 min read
Master Distributed Caching, Rate Limiting, Locks & Idempotency with Alibaba Tools
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Mar 22, 2020 · Backend Development

API Design Specification Guidelines for Backend Development

This article provides comprehensive API design guidelines covering routing naming conventions, request methods, parameter structures, security measures, response formats, signature design, logging platform setup, and idempotency strategies to help backend developers create consistent and reliable interfaces.

API designLoggingREST
0 likes · 6 min read
API Design Specification Guidelines for Backend Development
Big Data Technology & Architecture
Big Data Technology & Architecture
Feb 27, 2020 · Fundamentals

Message Queue Usage, Advantages, Disadvantages, and High‑Availability Design

The article explains why message queues are used, outlines their core scenarios—decoupling, asynchronous processing, and traffic shaping—compares Kafka, ActiveMQ, RabbitMQ, and RocketMQ, and details how to ensure high availability, reliability, idempotency, ordering, and scalability in production systems.

Message QueueRabbitMQidempotency
0 likes · 34 min read
Message Queue Usage, Advantages, Disadvantages, and High‑Availability Design
Big Data Technology & Architecture
Big Data Technology & Architecture
Feb 11, 2020 · Backend Development

Message Queue Interview Guide: Benefits, Drawbacks, High Availability, Idempotency, Ordering and Design Strategies

This article provides a comprehensive interview‑oriented overview of message queues, explaining why they are used, their core advantages and disadvantages, comparing Kafka, RabbitMQ, ActiveMQ and RocketMQ, and detailing high‑availability, reliability, idempotency, ordering, backlog handling and architectural design considerations.

Message QueueRabbitMQidempotency
0 likes · 33 min read
Message Queue Interview Guide: Benefits, Drawbacks, High Availability, Idempotency, Ordering and Design Strategies
Architecture Digest
Architecture Digest
Jan 21, 2020 · Backend Development

Implementing Idempotent Requests with Local Locks, AOP, and Redis in Java

This article explains the concept of idempotency in web services, analyzes common causes of duplicate submissions, and presents multiple backend solutions—including frontend button disabling, PRG pattern, session flags, local locks using ConcurrentHashMap, AOP interceptors, and distributed Redis locks—accompanied by complete Java code examples.

Springidempotency
0 likes · 13 min read
Implementing Idempotent Requests with Local Locks, AOP, and Redis in Java
Architecture Digest
Architecture Digest
Jan 7, 2020 · Backend Development

Ensuring 100% Message Delivery with RabbitMQ: Reliability Steps and Idempotent Design

This article explains how to achieve guaranteed 100% message delivery in RabbitMQ by leveraging its acknowledgment mechanisms, implementing producer‑side confirmation steps, designing compensation and retry logic, and ensuring consumer‑side idempotency through unique identifiers and various ID‑generation strategies.

Message DeliveryReliabilitydistributed systems
0 likes · 7 min read
Ensuring 100% Message Delivery with RabbitMQ: Reliability Steps and Idempotent Design
Java Captain
Java Captain
Jan 6, 2020 · Backend Development

Implementing API Idempotency with Redis Token Mechanism in Spring Boot

This article explains how to achieve interface idempotency in a Spring Boot application by generating a unique token for each request, storing it in Redis, validating the token via a custom annotation and interceptor, and provides complete code examples and testing guidance.

JavaRedisSpring Boot
0 likes · 16 min read
Implementing API Idempotency with Redis Token Mechanism in Spring Boot
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.

Distributed Lockdatabaseidempotency
0 likes · 9 min read
Ensuring Idempotency in Distributed Systems: Strategies and Best Practices
Programmer DD
Programmer DD
Dec 9, 2019 · Backend Development

How to Ensure Idempotency in Distributed Systems: Strategies and Code Examples

This article explains the importance of idempotent operations in backend systems, defines the concept, and presents practical techniques such as unique indexes, token mechanisms, pessimistic and optimistic locking, distributed locks, state‑machine design, and API patterns, complete with code snippets and diagrams.

LockingTokenbackend
0 likes · 10 min read
How to Ensure Idempotency in Distributed Systems: Strategies and Code Examples
Selected Java Interview Questions
Selected Java Interview Questions
Nov 1, 2019 · Backend Development

Implementing Idempotency for API Requests in Backend Development

The article explains how to improve system scalability through hardware and software architecture enhancements, defines idempotency and its importance for preventing duplicate processing, and describes a practical implementation using unique request identifiers to ensure consistent responses for repeated API calls.

APIMicroservicesidempotency
0 likes · 4 min read
Implementing Idempotency for API Requests in Backend Development
Programmer DD
Programmer DD
Aug 11, 2019 · Backend Development

Ensuring API Idempotency with Spring Boot, Redis, and Token Interceptor

This article explains the concept of idempotency, lists common solutions, and demonstrates a practical implementation using Spring Boot, Redis, and a token‑based mechanism with custom annotations and interceptors, including full code examples, testing steps, and important pitfalls to avoid.

APITokenidempotency
0 likes · 11 min read
Ensuring API Idempotency with Spring Boot, Redis, and Token Interceptor
Youzan Coder
Youzan Coder
Aug 9, 2019 · Backend Development

How Youzan Built a Scalable Task Center: Architecture, Idempotency, and Dynamic Config

This article explains why a task center is essential for merchants, outlines its goals, and details the backend architecture—including atomic APIs, Apollo-driven dynamic configuration, idempotent control, workflow orchestration, caching, and asynchronous logging—while also sharing future enhancements.

Asynchronous LoggingWorkflow Enginebackend-architecture
0 likes · 8 min read
How Youzan Built a Scalable Task Center: Architecture, Idempotency, and Dynamic Config
dbaplus Community
dbaplus Community
Jul 4, 2019 · Databases

How Tencent’s TDSQL Multi‑Source Sync Achieves High‑Performance, Consistent Data Distribution

This article explains the financial‑industry driven requirements for real‑time data sync, describes the TDSQL‑MULTISRCSYNC architecture—including producer, store, and consumer components—and details core designs such as row‑hash concurrency, idempotent binlog handling, and a lock‑based ordering mechanism that ensure high throughput and consistency.

Data synchronizationLockingMulti-Source Sync
0 likes · 13 min read
How Tencent’s TDSQL Multi‑Source Sync Achieves High‑Performance, Consistent Data Distribution
Java High-Performance Architecture
Java High-Performance Architecture
May 15, 2019 · Databases

How to Achieve Distributed Transaction Consistency with Message Queues

This article explains how to handle distributed transactions in microservice architectures by using eventual consistency with message middleware, discusses the pitfalls of combining database updates and message sending in a single transaction, and presents a reliable solution involving a message table, background processing, ACK mechanisms, and deduplication.

Microservicesdistributed transactionseventual consistency
0 likes · 5 min read
How to Achieve Distributed Transaction Consistency with Message Queues
Tencent Cloud Developer
Tencent Cloud Developer
May 14, 2019 · Operations

Handling Connection Loss and Session Expiry in ZooKeeper-based Distributed Locks

When using ZooKeeper‑based distributed locks, applications must detect CONNECTIONLOSS and SESSIONEXPIRED events, verify the master znode to confirm leadership, relinquish duties on session expiry, and design idempotent tasks to avoid split‑brain or duplicate execution caused by network partitions or quorum delays.

Distributed LockLeader ElectionZookeeper
0 likes · 10 min read
Handling Connection Loss and Session Expiry in ZooKeeper-based Distributed Locks
Java Backend Technology
Java Backend Technology
May 6, 2019 · Backend Development

Ensuring Zero Message Loss in RabbitMQ: Persistence, Confirm & Idempotency

This article explains how to guarantee that order service messages are reliably delivered to RabbitMQ by using durable queues, the confirm mechanism, early persistence with Redis and scheduled retries, and idempotent processing techniques to achieve near‑100% message safety in high‑concurrency environments.

Confirm MechanismRabbitMQdistributed systems
0 likes · 10 min read
Ensuring Zero Message Loss in RabbitMQ: Persistence, Confirm & Idempotency
Programmer DD
Programmer DD
Jan 18, 2019 · Backend Development

Mastering Compensation: When to Rollback vs Retry in Distributed Systems

This article explains the purpose of compensation mechanisms in microservice architectures, compares rollback and retry approaches, outlines their implementation details, discusses idempotency concerns, and provides practical best‑practice recommendations for building resilient distributed systems.

CompensationRollbackdistributed systems
0 likes · 12 min read
Mastering Compensation: When to Rollback vs Retry in Distributed Systems
21CTO
21CTO
Dec 31, 2018 · Backend Development

Designing Robust APIs: Principles, Practices, and Real-World Examples

This article explores core API design principles—clear mental models, simplicity, multiple implementations—and offers concrete best‑practice guidance, from documentation and resource modeling to idempotency, compatibility, batch updates, and error handling, illustrated with the classic POSIX File API.

API designcompatibilityidempotency
0 likes · 21 min read
Designing Robust APIs: Principles, Practices, and Real-World Examples
Alibaba Cloud Native
Alibaba Cloud Native
Dec 28, 2018 · Backend Development

Essential API Design Principles and Practical Guidelines

This article explores why API design is crucial for large‑scale software systems, outlines fundamental design principles, presents detailed best‑practice recommendations, and discusses compatibility, idempotency, error handling, and versioning with concrete examples such as the POSIX File API.

API designbest practicescompatibility
0 likes · 21 min read
Essential API Design Principles and Practical Guidelines
Architect's Tech Stack
Architect's Tech Stack
Dec 22, 2018 · Backend Development

Understanding Idempotency: Concepts, Examples, and Implementation Techniques

This article explains the mathematical and programming concept of idempotency, provides real‑world examples such as duplicate form submissions and payment requests, and details practical techniques—including query/select operations, unique indexes, token mechanisms, pessimistic and optimistic locks, distributed locks, and API design—to ensure idempotent behavior in backend systems.

Lockingdatabasedistributed systems
0 likes · 9 min read
Understanding Idempotency: Concepts, Examples, and Implementation Techniques
Hujiang Technology
Hujiang Technology
Nov 26, 2018 · Backend Development

Ensuring Distributed Final Consistency: Heavy and Light Approaches, Principles and Practices

The article explains distributed final consistency challenges, compares heavyweight transaction frameworks with lightweight techniques such as idempotency, retries, state machines, recovery logs, and async verification, and outlines CAP, BASE principles and practical implementation steps for backend systems.

BASECAP theoremMicroservices
0 likes · 14 min read
Ensuring Distributed Final Consistency: Heavy and Light Approaches, Principles and Practices
360 Tech Engineering
360 Tech Engineering
Jul 19, 2018 · Backend Development

Understanding Idempotency in Software Systems and How to Ensure It

The article explains the concept of idempotency, why it is critical for data consistency in backend services, and presents practical techniques such as unique business identifiers, locking, optimistic concurrency, deduplication tables, distributed locks, token mechanisms, and payment buffering to achieve reliable idempotent operations.

distributed systemsidempotency
0 likes · 5 min read
Understanding Idempotency in Software Systems and How to Ensure It
360 Quality & Efficiency
360 Quality & Efficiency
Jul 6, 2018 · Backend Development

Understanding Idempotency and How to Ensure It in Backend Systems

The article explains the mathematical definition of idempotency, its importance in preventing duplicate operations such as repeated payments or order creation, and presents practical strategies—including unique business IDs, optimistic locking, deduplication tables, distributed locks, token mechanisms, and payment buffering—to achieve reliable idempotent behavior in backend services.

DeduplicationTokenbackend
0 likes · 6 min read
Understanding Idempotency and How to Ensure It in Backend Systems
JD Tech
JD Tech
Jun 11, 2018 · Backend Development

Message Queue (MQ) Usage Scenarios, Patterns, and Pitfalls

Message queues enable asynchronous, decoupled communication between systems, and this article explains core scenarios such as decoupling, peak‑shaving, achieving eventual consistency, broadcast consumption, and retry handling, while highlighting implementation details, pull‑mode code, and important considerations like idempotency and consumption monitoring.

Asynchronous Communicationbroadcastdecoupling
0 likes · 10 min read
Message Queue (MQ) Usage Scenarios, Patterns, and Pitfalls
dbaplus Community
dbaplus Community
Jun 5, 2018 · Backend Development

Designing Highly Available Service Layers: Stateless, Timeouts, Async & Idempotency

This article explains how to build a highly available service layer by vertically splitting business domains, adopting stateless architecture, configuring timeout policies, using asynchronous calls with message queues, ensuring idempotent operations, and applying service degradation techniques to handle traffic spikes and failures.

Asynchronousbackendidempotency
0 likes · 13 min read
Designing Highly Available Service Layers: Stateless, Timeouts, Async & Idempotency
Java Captain
Java Captain
May 30, 2018 · Backend Development

Key Points for Revisiting Message Queue Middleware: Usage, Drawbacks, Selection, High Availability, Idempotency, Reliability, and Ordering

This article reviews essential concepts of message queue middleware, covering why to use it, its drawbacks, selection criteria, high‑availability designs, preventing duplicate consumption, ensuring reliable transmission, and maintaining message order, providing a concise study guide for developers and architects.

MQMessage QueueReliability
0 likes · 21 min read
Key Points for Revisiting Message Queue Middleware: Usage, Drawbacks, Selection, High Availability, Idempotency, Reliability, and Ordering
Architecture Digest
Architecture Digest
Apr 23, 2018 · Backend Development

Designing High‑Concurrency Architecture: Principles, Idempotency, Rate Limiting and a Token‑Bucket Demo

The article explains how to design a backend architecture that can handle millions of concurrent requests by applying principles such as service decomposition, high availability, idempotent business logic, and various rate‑limiting algorithms—including sliding window, leaky bucket and token bucket—with a runnable Java demo.

High concurrencyToken Bucketbackend-architecture
0 likes · 11 min read
Designing High‑Concurrency Architecture: Principles, Idempotency, Rate Limiting and a Token‑Bucket Demo
Alibaba Cloud Infrastructure
Alibaba Cloud Infrastructure
Nov 29, 2017 · Databases

Case Study: Resolving a One‑Cent Discrepancy Caused by Distributed‑Lock Timeout and Concurrency Issues in Alibaba’s Financial System

This article analyzes a real Alibaba internal financial‑system incident where a one‑cent accounting error arose from concurrent database writes after a distributed‑lock timeout, details the root‑cause investigation, and presents two remediation strategies—adjusting timeout settings and strengthening idempotent controls—to prevent similar issues.

AlibabaDistributed Lockconcurrency
0 likes · 7 min read
Case Study: Resolving a One‑Cent Discrepancy Caused by Distributed‑Lock Timeout and Concurrency Issues in Alibaba’s Financial System
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 27, 2017 · Backend Development

How a 0.01‑Yuan Mistake Exposed Distributed Lock Flaws in Alibaba’s Backend

A tiny 0.01‑yuan discrepancy in an Alibaba product revealed duplicate settlement records, exposing a distributed‑lock timeout and concurrency issue that led to double commits, and the article walks through the root‑cause analysis, reverse engineering of the process, and two remediation strategies focusing on timeout adjustments and idempotency controls.

AlibabaDistributed Lockconcurrency
0 likes · 8 min read
How a 0.01‑Yuan Mistake Exposed Distributed Lock Flaws in Alibaba’s Backend
21CTO
21CTO
Oct 22, 2017 · Operations

How to Build Highly Available Systems: Fault Tolerance and Scalability Strategies

This article explains why high availability is critical for internet services, outlines key techniques such as stateless design, service discovery, heartbeat checks, idempotent operations, load balancing, throttling, caching, and micro‑service architecture, and discusses the operational challenges and monitoring tools needed to maintain resilient, scalable systems.

High AvailabilityMicroservicesfault tolerance
0 likes · 8 min read
How to Build Highly Available Systems: Fault Tolerance and Scalability Strategies
Architecture Digest
Architecture Digest
Oct 22, 2017 · Operations

Ensuring High Availability in Internet Services: Stateless Design, Service Discovery, Idempotency, Rate Limiting, and Microservices

The article discusses how to achieve high availability for large‑scale internet services by adopting stateless architecture, service discovery and registration, heartbeat monitoring, idempotent design, retry mechanisms, rate limiting, caching, and micro‑service decomposition to handle machine failures, network glitches, and high concurrency.

CachingHigh AvailabilityMicroservices
0 likes · 9 min read
Ensuring High Availability in Internet Services: Stateless Design, Service Discovery, Idempotency, Rate Limiting, and Microservices
Dada Group Technology
Dada Group Technology
Aug 25, 2017 · Backend Development

Designing a High‑Availability Inventory System: Stock Pre‑allocation, Idempotency, Concurrency Control, and Rollback Strategies

The article describes how JD Daojia's inventory system serves millions of stores by using health‑monitoring platforms, pre‑allocation policies, idempotent order processing, distributed locks, and rollback mechanisms to ensure stability, prevent overselling, and handle high‑concurrency scenarios such as flash‑sales.

Distributed LockInventoryidempotency
0 likes · 11 min read
Designing a High‑Availability Inventory System: Stock Pre‑allocation, Idempotency, Concurrency Control, and Rollback Strategies
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 9, 2017 · Backend Development

Mastering Distributed Locks and Idempotency for High‑Concurrency Systems

This article explores the challenges of mutual exclusion and idempotency in distributed environments, explains the underlying principles of locks in multi‑threaded and multi‑process contexts, and presents practical implementations using Zookeeper, Redis, Tair, and the Cerberus and GTIS frameworks to ensure reliable, scalable operations.

Distributed LockRedisZookeeper
0 likes · 35 min read
Mastering Distributed Locks and Idempotency for High‑Concurrency Systems
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 7, 2017 · Backend Development

Ensuring Idempotency in High‑Concurrency Systems: Strategies and Best Practices

To prevent duplicate operations such as repeated inserts, updates, or message sends in high‑traffic applications, this article explains the concept of idempotency and outlines practical techniques—including read‑only APIs, MVCC with optimistic locking, deduplication tables, distributed locks, safe deletes, unique indexes, UUID‑based request tracking, and state‑machine safeguards.

Distributed LockHigh concurrencybackend
0 likes · 5 min read
Ensuring Idempotency in High‑Concurrency Systems: Strategies and Best Practices
Architecture Digest
Architecture Digest
Apr 1, 2017 · Backend Development

Distributed Consistency and Transactional Messaging Solutions

This article explains the challenges of achieving consistency in distributed systems and presents practical solutions such as two‑phase commit, asynchronous assurance, compensating transactions, message retry mechanisms, idempotent designs, and a custom Redis‑based delayed queue (DelayQ) with a transactional proxy (TMQProxy) to provide reliable transactional messaging.

Redis delay queueTransactional Messagingdistributed systems
0 likes · 19 min read
Distributed Consistency and Transactional Messaging Solutions
Architecture Digest
Architecture Digest
Mar 9, 2017 · Backend Development

Common Design Issues and Best Practices for Distributed System Interfaces

The article outlines key challenges in distributed API design—including date formatting, decimal precision, response structures, idempotency, security, and naming consistency—and provides practical recommendations to improve usability, scalability, and maintainability across backend services.

API designbackenddata dictionary
0 likes · 12 min read
Common Design Issues and Best Practices for Distributed System Interfaces
Meituan Technology Team
Meituan Technology Team
Oct 1, 2016 · Backend Development

Analysis of Mutual Exclusion and Idempotency Issues in Distributed Systems and Their Solutions

The article examines how distributed systems face mutual‑exclusion and idempotency challenges, explains traditional thread and process synchronization, then details distributed‑lock techniques (e.g., Zookeeper, Redis, Tair, Cerberus) and global‑ID‑based idempotent services, emphasizing the importance of external storage, fault‑tolerance, and proper lock granularity for reliable high‑throughput applications.

Distributed LockJava concurrencyRedis
0 likes · 36 min read
Analysis of Mutual Exclusion and Idempotency Issues in Distributed Systems and Their Solutions
High Availability Architecture
High Availability Architecture
Jul 15, 2016 · Backend Development

High‑Availability Architecture for Weibo Paid Reading and Tipping Services

The article describes the high‑availability, high‑concurrency backend architecture of Weibo's paid reading and tipping platform, covering layered design, database sharding, asynchronous processing, monitoring, idempotency, distributed transaction handling, and security measures for a large‑scale internet‑finance system.

Monitoringbackenddistributed-systems
0 likes · 8 min read
High‑Availability Architecture for Weibo Paid Reading and Tipping Services