A simplified classical database transaction can be viewed as:
- reading M items
- performing some calculation based on those reads
- writing some N results based on these calculations, which may include the elements originally read.
When performing these transactions (concurrently) the ACID properties need to be maintained.
Exactly the same requirements (N updates based on M reads transactionally) exist in other non-DBMS concurrent systems.
I'm interested in finding out what algorithms exist for performing/resolving these transactions, and what the relative strengths and weaknesses of these algorithms are. Could you recommend some reading? This could be books or online references/tutorials.
So for example, a naive algorithm might be each transaction taking a single global lock, in effect forcing single threading and removing concurrency. A slightly more complicated algorithm would be individual item read/write locks, with an ordering to avoid deadlock). Etc, etc. Is there a good source documenting various algorithms for solving this problem. Even an answer which only pointed to a single algorithm with it's strength and weaknesses would be useful.