Concurrency control

From Wikipedia, the free encyclopedia

In computer science — more specifically, in the field of databases and database theory — concurrency control is a method used to ensure that database transactions are executed in a safe manner (i.e., without data loss). Concurrency control is especially applicable to database management systems (DBMS), which must ensure that transactions are executed safely and that they follow the ACID rules, as described in the following section. The DBMS must be able to ensure that only serializable, recoverable schedules are allowed, and that no actions of committed transactions are lost while undoing aborted transactions.

In computer science — in the field of concurrent programming (see also parallel programming and parallel computing on multiprocessor machines) — concurrency control is a method used to ensure that correct results are generated, while getting those results as quickly as possible.

Several algorithms can be used for either type of concurrency control (i.e., with in-RAM data structures on systems that have no database, or with on-disk databases).

1 Transaction ACID rules
2 Concurrency control mechanism
3 See also
4 External links

[edit] Transaction ACID rules

Atomicity - Either all or no operations are completed - in other words to the outside world the transaction appears to happen indivisibly (Undo)
Consistency - All transactions must leave the database in a consistent state.
Isolation - Transactions cannot interfere with each other.
Durability - Successful transactions must persist through crashes. (Redo)

[edit] Concurrency control mechanism

The main categories of concurrency control mechanisms are:

Optimistic - Delay the synchronization for transactions until the operations are performed. Conflicts are less likely but won't be known until they happen.
Pessimistic - The potentially concurrent executions of transactions are synchronized early in their execution life cycle. Blocking is thus more likely but will be known earlier.

There are many methods for concurrency control, the majority of which uses Strict 2PL locking:

Locks are bookkeeping objects associated with a database object.

There are also non-lock concurrency control methods. All the currently implemented lock-based and almost all the implemented non-lock based concurrency controls will guarantee that the resultant schedule is conflict serializable; however, there are many academic texts encouraging view serializable schedules for environments where gains due to improvement in concurrency outstrip overheads in generating schedule plans.