Two concurrent bank transactions, T1 and T2, were attempting to withdraw $50 from Account1. The software transactional memory (STM) detected a conflict when T1 committed first, causing T2 to retry with the updated balances. On the retry, T2 saw the changes from T1 and successfully committed without issue.

1. Two concurrent bank transactions.
If there is inconsistency, money can appear or money can disappear.

2. Transactions are stated at the same time.

3. Transaction 1 (T1) reads the Account1 balance and takes a snapshot.
The snapshot is now in the transaction scope.

4. Transaction 2 (T2) also reads the Account1 balance.

5. Each transaction now has its isolated snapshot of the Account1 balance.

6. T1 updates Account1 balance snapshot to 100-50=50

7. T2 also updates Account1 balance snapshot to 100-50=50

8. T1 reads the Account2 balance and takes a snapshot.

9. T2 also reads the Account2 balance and takes a snapshot.

10. Each transaction now has its isolated snapshot of the Account2 balance.

11. T1 updates Account2 balance snapshot to 0+50=50

12. T1 also updates Account2 balance snapshot to 0+50=50

13. T1 ends first and can commit the Account 1 balance new value.

14. Commit the Account2 balance.

15. The STM detects that T2 has reads and writes conflicts with the T1 already commited
values.

16. Assuming that T2 does not have side effects, it can be executed again (retried).

17. On T2 retry, the T1 is already finished.

18. T2 reads the Account1 balance and takes a snapshot.

19. T2 updates its Account1 balance snapshot to 50-50=0

20. T2 reads the Account2 balance and takes a snapshot.

21. T2 updates its Account2 balance snapshot to 50+50=100

22. T2 commit Account1 balance.

23. T2 commit Account2 balance.

24. The two transactions end with success. Reads and writes were isolated and the STM
detected the conflict, resolving it with the T2 retry.