Concurrency control

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.

Contents

[edit] Concurrency control in databases

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.

[edit] Transaction ACID rules

  • 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.

[edit] Concurrency control mechanism

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:

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:

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.

[edit] Concurrency control in operating systems

Operating systems, especially real-time operating systems, need to maintain the illusion that many tasks are all running at the same time. Such multitasking is fairly simple when all tasks are independent from each other. However, when several tasks try to use the same resource, or when tasks try to share information, it can lead to confusion and inconsistency. The task of concurrent computing is to solve that problem. Some solutions involve "locks" similar to the locks used in databases, but they risk causing problems of their own such as deadlock. Other solutions are lock-free and wait-free algorithms.

[edit] See also

[edit] External links