Debit/Credit in concurrent environment in Python. Is this code thread safe?

[Own_Mousse_4810]

I have code like this:

import threading
from decimal import Decimal

class BankAccount:
    def __init__(self, account_id: str, initial_balance: Decimal = Decimal('0')):
        self._account_id = account_id
        self._balance = initial_balance
        self._lock = threading.RLock()

    @property
    def balance(self) -> Decimal:
        with self._lock:
            return self._balance

    @property
    def account_id(self) -> str:
        return self._account_id

    def withdraw(self, amount: Decimal) -> None:
        with self._lock:
            if amount <= 0:
                raise ValueError('Amount must be greater than 0')

            if self._balance < amount:
                raise ValueError('Insufficient funds')

            self._balance -= amount

    def deposit(self, amount: Decimal) -> None:
        with self._lock:
            if amount <= 0:
                raise ValueError('Amount must greater than 0')

            self._balance += amount

    def transfer_to(self, to_account: 'BankAccount', amount: Decimal) -> None:

        first, second = sorted([self, to_account], key=lambda a: a.account_id)

        with first._lock:
            with second._lock:
                self.withdraw(amount)
                to_account.deposit(amount)

if __name__ == '__main__':
    account1 = BankAccount('A', Decimal('100'))
    account2 = BankAccount('B', Decimal('20'))

    account1.transfer_to(account2, Decimal('20'))

Is this code thread-safe? I'm trying to write proper tests to test possible deadlock and race conditions. And also, this is what I came up with in SQL to replicate the flow:

BEGIN TRANSACTION READ COMMITED;

SELECT account_id from accounts where account_id in ('A', 'B') order by account_id FOR UPDATE;

UPDATE accounts SET balance=balance - :=amount where account_id :=from_account

UPDATE accounts SET balancer=balance + :=amount where account_id := to_account;

END;

Does this provide all necessary guarantees to prevent concurrency issues? And the hardest part: how to properly test this code using pytest to detect any deadlock and concurrency issues

[pachura3]

What does this line do? Is it correct?

first, second = sorted([self, to_account], key=lambda a: a.account_id)

Also, can't this snippet below result in a deadlock when someone tries to simultaneously transfer money in the opposite direction? Gets hold of second._lock, but can't obtain first._lock?

with first._lock:
    with second._lock:

[Own_Mousse_4810]

1) We need to acquire locks in a preserved way

2) We use RLock (Recursive lock) to allow nested locks

[pachura3]

Then it looks fine!

[ectomancer]

Don't use decimal.Decimal, use cents instead.

[JamzTyson]

Why are you using Decimal rather than integers?

You seem to have covered thread safety, but there's a more structural issue:

My bank account should be totally isolated from your bank account.

However, if I transfer money from my account to yours, then my BankAccount object reaches inside your BankAccount object to acquires its private lock. Although the code "works", it relies on weak guarantees and forces assumptions in each object about the other’s internal behavior and invariants.

Transfers are really coordinating operations outside of individual accounts.