How to solve the double payment problem in case of a database write failure?

The double payment problem occurs when a database write operation is interrupted after money has been deducted but before the transaction is confirmed, and upon retrying, the deduction happens again.

To prevent this, the following approaches are used:

1. Idempotency of the operation — the operation should have a unique identifier (e.g., transaction_id), and on subsequent calls with the same ID, the system should not deduct again.

2. Transactions and atomicity — use database transactions so that deduction and recording happen atomically.

3. State fixation — store the status of the operation (e.g., "in progress", "successful", "error") and check it before reprocessing.

4. Use of distributed locks or semaphores to prevent parallel execution of the same operation.

Example of an idempotent function in Python using a unique transaction_id:

processed_transactions = set()

def process_payment(transaction_id, amount):
    if transaction_id in processed_transactions:
        print("Payment already processed")
        return
    # Logic for deducting money
    # Recording in the database
    processed_transactions.add(transaction_id)
    print("Payment successfully processed")

In a real system, processed_transactions would be a table in the database with a unique index on transaction_id.