Concurrency Control MCQ Quiz in తెలుగు - Objective Question with Answer for Concurrency Control - ముఫ్త్ [PDF] డౌన్‌లోడ్ కరెన్

• Strict 2PL allows only schedules whose precedence graph is acyclic i.e. schedule is Conflict Serial.
• In 2PL, transactions do not release exclusive locks until the transaction has committed or aborted i.e. schedule is recoverable.
• Timestamp ordering schedule with Thomas write rule generate View serial schedule with BLIND WRITE. Because of BLIND WRITE it won't be Conflict Serial.

• Two Phase locking ensures conflict serializability but does not ensure deadlock freedom. But time stamp ordering ensures both deadlock freedom and conflict serializability.

A transaction is said to follow 2- phase locking protocol if locking and unlocking can be done in 2 phases:

1) Growing phase: New locks on data items may be acquired but none can be released.

2) Shrinking phase: Existing locks may be released but no new locks can be acquired.

Properties of conservative 2PL:

A 2PL schedule is serializable, strict recoverable, deadlock free, starvation free.

Here, locks are acquired in order O₁, O₂, O₃,……….O_k (increasing order). Locks are also not released until the transaction completes its operation. Here circular wait condition can never occur. Hence, there is no possibility of deadlock.

Concept:

Simple locking scheme:

1. Shared lock (S) 2. An exclusive lock (X)

Shared Lock (S): If transaction locked data item in shared mode, allowed to read-only.

Exclusive Lock (X): If transaction locked data item in shared mode, allowed to read and write both.                                                            

Explanation:

From the above table, we can see that if one transaction has a shared lock on a data item and if

The correct answer is In growing phase, transaction can only obtain locks and in shrinking phase, it can only release locks.

Key PointsTwo-phase locking (2PL) is a concurrency control method that ensures serializability. It is divided into two phases:

• Growing Phase: During this phase, a transaction can only acquire or obtain locks and cannot release any locks it has already obtained. This phase allows the transaction to lock additional resources as needed but ensures that once it starts releasing locks, it cannot lock more resources. This helps prevent deadlock and ensures a strict ordering of operations.
• Shrinking Phase: After the transaction has acquired all the locks it needs, it enters the shrinking phase, where it can only release locks and cannot obtain any new locks. This phase concludes as the transaction releases all its locks, either by committing or aborting. The release of locks in the shrinking phase allows other transactions to proceed, thus facilitating concurrent access to the database while maintaining consistency and isolation.

The two-phase locking protocol guarantees conflict serializability and prevents certain types of deadlocks, although it doesn't entirely eliminate the risk of deadlocks. The strict division into growing and shrinking phases is crucial for maintaining the integrity of transactions and ensuring that the database operates consistently and correctly under concurrent access.

The correct answer is Two-phase locking

Key Points

• Two-phase locking is a concurrency control mechanism used to ensure the consistency and integrity of a database in a concurrent transaction scenario. It involves two phases: the growing phase and the shrinking phase.
• In the growing phase, transactions can acquire locks but cannot release any.
• In the shrinking phase, transactions can release locks but cannot acquire any.
• This protocol helps in preventing issues such as lost updates, uncommitted data, and inconsistency that may arise due to concurrent execution of transactions.

The correct answer is Deadlock

Key Points

• Deadlocks occur when two or more processes hold locks on resources and each process is waiting to acquire a lock on a resource that the other process holds. None of the processes can proceed, resulting in a standoff. This is a common problem in database systems and applications where concurrency is managed through locking mechanisms.

Additional Information

• Information overwrite, loss of information, and lack of integrity are issues that locking mechanisms aim to prevent by ensuring transactions do not interfere with each other. Properly implemented locks help maintain data integrity and prevent concurrent transactions from corrupting data. 

The correct answer is Statement I is incorrect but Statement II is correct

Key Points

• Two-phase locking (2PL):
  • In this protocol, each transaction goes through two phases:
    • The expanding (or growing) phase where locks are acquired, and the shrinking phase where locks are released.
    • The name "two-phase" comes from the fact that all lock acquisitions occur before any lock is released.
    • This ensures a level of consistency and conflict serializability, as two conflicting transactions can't be running at the same time.
    • However, this method doesn't guarantee a deadlock-free environment.
    • A deadlock situation can occur when two (or more) transactions each hold a resource the other needs, creating a standoff where neither can proceed.
• Timestamp-based protocol:
  • In timestamp-based protocols, each transaction is assigned a unique timestamp at the moment it is created.
  • There are two types of timestamp protocols:
    • Thomas Write Rule and Basic Timestamp Ordering. The one that provides both conflict serializability and freedom from deadlock is the Basic Timestamp Ordering.
    • This protocol ensures each transaction respects the chronological (timestamp) order of other transactions. When conflicts arise (for example if a later (younger) transaction tries to write data that an earlier (older) transaction is reading or writing), the conflicting transaction can be rolled back and restarted to prevent the scenario from causing inconsistency, thus ensuring conflict serializability.
    • And since a younger transaction will always concede to an older one by being rolled back and restarted, there's no chance for deadlocks to occur, thus ensuring freedom from deadlock.

So, Statement I is incorrect because Two-phase locking (2PL) does not ensure freedom from deadlock, and Statement II is correct because Timestamp-based protocol ensures both conflict serializability and freedom from deadlock.