DBMS Concurrency Control - NotesVeda
Concurrency
control is a technique used in database management systems (DBMSs) to ensure
that multiple transactions can access the same data simultaneously without
causing conflicts or data corruption.
Concurrency Control
Concurrency control is a technique used in database management systems
(DBMSs) to ensure that multiple transactions can access the same data
simultaneously without causing conflicts or data corruption. It is a mechanism
that coordinates the execution of multiple transactions to ensure consistency,
isolation, and integrity of the database.
There are two main types of concurrency control techniques:
1.
Pessimistic concurrency control: In this technique,
a transaction is not allowed to access a data item until it has acquired a lock
on it. Locks can be of different types such as shared locks and exclusive
locks. This technique ensures that two transactions cannot modify the same data
item at the same time, but it can cause contention and delays if many
transactions are trying to access the same data item.
2.
Optimistic concurrency control: In this technique,
transactions are allowed to access data items without acquiring locks. Instead,
they are required to check the consistency of the data item before modifying
it. If the data item has been modified by another transaction, the modification
is rejected and the transaction must be restarted. This technique reduces
contention and delays, but it can result in more complex code and the need for
additional error handling.
There are various algorithms for implementing these techniques, such as Two-Phase
Locking, Timestamp-based protocols, Multi-version Concurrency Control (MVCC)
and Conflict-free Replicated Data Types (CRDTs) etc.
In summary, concurrency control is a technique used in DBMSs to ensure
that multiple transactions can access the same data simultaneously without
causing conflicts or data corruption. There are two main types of concurrency
control techniques: pessimistic and optimistic concurrency control.
Pessimistic concurrency control uses locks to prevent
conflicts, while optimistic concurrency control checks data consistency
before modifications. Both techniques have their own advantages and
disadvantages and the choice depends on the use case.
Lock based protocol
A lock-based protocol is a mechanism for controlling access to shared resources in a concurrent or multi-threaded environment. It uses locks, which are a synchronization mechanism, to ensure that only one thread can access a shared resource at a time. This prevents race conditions, where multiple threads try to access or modify the same resource simultaneously, which can lead to unpredictable or incorrect behavior. Lock-based protocols are widely used in multi-threaded programming, and are implemented in many programming languages and libraries.
Timestamp based protocol
A timestamp-based protocol is a mechanism for ordering events in a
distributed system. It assigns a timestamp to each event, and uses these
timestamps to determine the order in which events occurred. This is typically
used to ensure consistency and prevent conflicts in a distributed system, where
multiple nodes may be updating shared resources simultaneously.
In a timestamp-based protocol, each node in the system has a
logical clock, which is used to assign timestamps to events. When a node
generates an event, it assigns the current value of its clock to the event, and
then increments the clock. When a node receives an event from another node, it
compares the timestamp of the event with the current value of its clock, and
updates its clock if the received timestamp is greater.
The main protocol of this kind is known as "Lamport timestamp".
Lamport timestamp This protocol uses a logical clock that is incremented monotonically by each
process, and assigns the value of the logical clock to each of its events. This
is the base for many other protocols like Vector timestamps, Conflict-free
replicated data types (CRDTs) and others.
Timestamp-based protocols are widely used in distributed
systems, databases and other systems that need to maintain consistency and
order in the presence of concurrent updates.
Validation based protocol
A validation-based protocol is a mechanism for ensuring the consistency
and validity of data in a distributed system. It uses validation rules or
constraints to check that data meets certain conditions before it is accepted
or processed. This can be used to prevent errors or inconsistencies caused by
malformed or invalid data.
Validation-based protocols are used in many different types of systems,
such as databases, distributed ledgers, and messaging systems. They can be
applied at different levels, such as at the client-side, at the server-side, or
at both.
There are different types of validation rules, such as syntax
validation, semantic validation, and business rule validation.
Syntax validation checks that data is in the correct format, such as
checking that a phone number is in the correct format.
Semantic validation checks that data has the correct meaning, such as
checking that a date is a valid date.
Business rule validation checks that data meets certain business rules,
such as checking that a price is above a certain minimum.
Validation-based protocols are important in ensuring the integrity and
consistency of data, especially in distributed systems where multiple nodes may
be updating shared resources simultaneously.
0 Comments
If You Have Any Doubts, Please tell me know