Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/dbms/concurrency-control-in-dbms/ below:

Concurrency Control in DBMS - GeeksforGeeks

Last Updated : 23 Jul, 2025

In a database management system (DBMS), allowing transactions to run concurrently has significant advantages, such as better system resource utilization and higher throughput. However, it is crucial that these transactions do not conflict with each other. The ultimate goal is to ensure that the database remains consistent and accurate. For instance, if two users try to book the last available seat on a flight at the same time, the system must ensure that only one booking succeeds.Concurrency control is a critical mechanism in DBMS that ensures the consistency and integrity of data when multiple operations are performed at the same time.

• Concurrency control is a concept in Database Management Systems (DBMS) that ensures multiple transactions can simultaneously access or modify data without causing errors or inconsistencies. It provides mechanisms to handle the concurrent execution in a way that maintains ACID properties.
• By implementing concurrency control, a DBMS allows transactions to execute concurrently while avoiding issues such as deadlocks, race conditions, and conflicts between operations.
• The main goal of concurrency control is to ensure that simultaneous transactions do not lead to data conflicts or violate the consistency of the database. The concept of serializability is often used to achieve this goal.

In this article, we will explore the various concurrency control techniques in DBMS, understand their importance, and learn how they enable reliable and efficient database operations.

In a multi-user system, several users can access and work on the same database at the same time. This is known as concurrent execution, where the database is used simultaneously by different users for various operations. For instance, one user might be updating data while another is retrieving it.

When multiple transactions are performed on the database simultaneously, it is important that these operations are executed in an interleaved manner. This means that the actions of one user should not interfere with or affect the actions of another. This helps in maintaining the consistency of the database. However, managing such simultaneous operations can be challenging, and certain problems may arise if not handled properly. These challenges need to be addressed to ensure smooth and error-free concurrent execution.

Concurrent Execution can lead to various challenges:

• Dirty Reads: One transaction reads uncommitted data from another transaction, leading to potential inconsistencies if the changes are later rolled back.
• Lost Updates: When two or more transactions update the same data simultaneously, one update may overwrite the other, causing data loss.
• Inconsistent Reads: A transaction may read the same data multiple times during its execution, and the data might change between reads due to another transaction, leading to inconsistency.

To read more about Concurrency Problems in DBMS Transactions Refer, Here.

Consider the following example:

• Without Concurrency Control: Transactions interfere with each other, causing issues like lost updates, dirty reads or inconsistent results.

• With Concurrency Control: Transactions are properly managed (e.g., using locks or timestamps) to ensure they execute in a consistent, isolated manner, preserving data accuracy.

Concurrency control is critical to maintaining the accuracy and reliability of databases in multi-user environments. By preventing conflicts and inconsistencies during concurrent transactions, it ensures the database remains consistent and correct, even under high levels of simultaneous activity.

Concurrency control protocols are the set of rules which are maintained in order to solve the concurrency control problems in the database. It ensures that the concurrent transactions can execute properly while maintaining the database consistency. The concurrent execution of a transaction is provided with atomicity, consistency, isolation, durability, and serializability via the concurrency control protocols.

• Locked based concurrency control protocol
• Timestamp based concurrency control protocol

1. Recoverable Schedules

• A recoverable schedule ensures that a transaction commits only if all the transactions it depends on have committed. This avoids situations where a committed transaction depends on an uncommitted transaction that later fails, leading to inconsistencies.
  • Concurrency control ensures recoverable schedules by keeping track of which transactions depend on others. It makes sure a transaction can only commit if all the transactions it relies on have already committed successfully. This prevents issues where a committed transaction depends on one that later fails.
  • Techniques like strict two-phase locking (2PL) enforce recoverability by delaying the commit of dependent transactions until the parent transactions have safely committed.

2. Cascadeless Schedules

• A cascadeless schedule avoids cascading rollbacks, which occur when the failure of one transaction causes multiple dependent transactions to fail.
  • Concurrency control techniques such as strict 2PL or timestamp ordering ensure cascadeless schedules by ensuring dependent transactions only access committed data.
  • By delaying read or write operations until the transaction they depend on has committed, cascading rollbacks are avoided.

To read more about different types of schedules based on Recoverability Refer, Here.

In general, concurrency means that more than one transaction can work on a system. The advantages of a concurrent system are:

• Waiting Time: It means if a process is in a ready state but still the process does not get the system to get execute is called waiting time. So, concurrency leads to less waiting time.

• Response Time: The time wasted in getting the response from the CPU for the first time, is called response time. So, concurrency leads to less Response Time.

• Resource Utilization: The amount of Resource utilization in a particular system is called Resource Utilization. Multiple transactions can run parallel in a system. So, concurrency leads to more Resource Utilization.

• Efficiency: The amount of output produced in comparison to given input is called efficiency. So, Concurrency leads to more Efficiency.

• Overhead: Implementing concurrency control requires additional overhead, such as acquiring and releasing locks on database objects. This overhead can lead to slower performance and increased resource consumption, particularly in systems with high levels of concurrency.

• Deadlocks: Deadlocks can occur when two or more transactions are waiting for each other to release resources, causing a circular dependency that can prevent any of the transactions from completing. Deadlocks can be difficult to detect and resolve, and can result in reduced throughput and increased latency.

• Reduced concurrency: Concurrency control can limit the number of users or applications that can access the database simultaneously. This can lead to reduced concurrency and slower performance in systems with high levels of concurrency.

• Complexity: Implementing concurrency control can be complex, particularly in distributed systems or in systems with complex transactional logic. This complexity can lead to increased development and maintenance costs.

• Inconsistency: In some cases, concurrency control can lead to inconsistencies in the database. For example, a transaction that is rolled back may leave the database in an inconsistent state, or a long-running transaction may cause other transactions to wait for extended periods, leading to data staleness and reduced accuracy.

Concurrency control ensures transaction atomicity, isolation, consistency and serializability. Concurrency control issues occur when many transactions execute randomly. A dirty read happens when a transaction reads data changed by an uncommitted transaction. When two transactions update data simultaneously, the Lost Update issue occurs. Lock-based protocol prevents incorrect read/write activities. Timestamp-based protocols organize transactions by timestamp.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4