From Wikipedia, the free encyclopedia

In computer science, especially in the fields of computer programming (see also concurrent programming, parallel programming), operating systems (see also parallel computing) , multiprocessors, and databases, concurrency control ensures that correct results for concurrent operations are generated, while getting those results as quickly as possible.

Concurrency control in database management systems (DBMS) ensures that database transactions are performed concurrently without the concurrency violating the data integrity of a database. Transactions should be executed safely and follow the ACID rules, as described below. The DBMS must guarantee that only serializable (unless Serializability is relaxed), recoverable schedules are generated, and also that no committed actions are lost while undoing aborted transactions.

• Atomicity - Either the effects of all or none of its operations remain when a transaction is completed - in other words, to the outside world the transaction appears to be indivisible, atomic.
• Consistency - Every transaction must leave the database in a consistent state.
• Isolation - Transactions cannot interfere with each other. Providing isolation is the main goal of concurrency control.
• Durability - Successful transactions must persist through crashes.

The main categories of concurrency control mechanisms are:

• Optimistic - Delay the synchronization for a transaction until its end without blocking (read, write) operations, and then abort transactions that violate desired synchronization rules.
• Pessimistic - Block operations of transaction that would cause violation of synchronization rules.

There are several methods for concurrency control. Among them:

• Two-phase locking
• Strict two-phase locking
• Conservative two-phase locking
• Index locking
• Multiple granularity locking

A Lock is a database system object associated with a database object (typically a data item) that prevents undesired (typically synchronization rule violating) operations of other transactions by blocking them. Database system operations check for lock existence, and halt when noticing a lock type that is intended to block them.

There are also non-lock concurrency control methods, among them:

• Conflict (serializability, precedence) graph checking
• Timestamp ordering
• commitment ordering

Almost all currently implemented lock-based and non-lock-based concurrency control mechanisms guarantee schedules that are conflict serializable (unless relaxed forms of serializability are needed). However, there are many research texts encouraging view serializable schedules for possible gains in performance, especially when not too many conflicts exist (and not too many aborts of completely executed transactions occur), due to reducing the considerable overhead of blocking mechanisms.

• Portland Pattern Repository: Synchronization Strategies
• Portland Pattern Repository: Category Concurrency