Scribd
Upload
30 views13 pages

Locking Protocol

Uploaded by

shalini20july
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
30 views13 pages

Locking Protocol

Uploaded by

shalini20july
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 13

Types of Lock

1.Shared Lock (S): Shared Lock is also known as Read-only lock. As the name
suggests it can be shared between transactions because while holding this lock
the transaction does not have the permission to update data on the data item. S-
lock is requested using lock-S instruction.
2.Exclusive Lock (X): Data item can be both read as well as written.This is
Exclusive and cannot be held simultaneously on the same data item. X-lock is
requested using lock-X instruction.

Lock Compatibility Matrix


A transaction may be granted a lock on an item if the requested lock is
compatible with locks already held on the item by other transactions. Any number
of transactions can hold shared locks on an item, but if any transaction holds an
exclusive(X) on the item no other transaction may hold any lock on the item. If a
lock cannot be granted, the requesting transaction is made to wait till all
incompatible locks held by other transactions have been released. Then the lock
is granted.
Concurrency Control Protocols
Concurrency Control Protocol allow concurrent schedules, but ensure that the
schedules are conflict/view serializable, and are recoverable and maybe even
cascadeless. These protocols do not examine the precedence graph as it is
being created, instead a protocol imposes a discipline that avoids non-
serializable schedules. Different concurrency control protocols provide different
advantages between the amount of concurrency they allow and the amount of
overhead that they impose.
• Lock Based Protocol
• Basic 2-PL
• Conservative 2-PL
• Strict 2-PL
• Rigorous 2-PL
• Graph Based Protocol
• Time-Stamp Ordering Protocol
• Multiple Granularity Protocol
• Multi-version Protocol

1. Simplistic Lock Protocol

It is the simplest method for locking data during a transaction. Simple lock-based protocols enable all
transactions to obtain a lock on the data before inserting, deleting, or updating it. It will unlock the data item
once the transaction is completed.

2. Pre-claiming Lock Protocol

• Pre-claiming Lock Protocols evaluate the transaction to list all the data items on which they need locks.

• Before initiating an execution of the transaction, it requests DBMS for all the lock on all those data items.
• If all the locks are granted then this protocol allows the transaction to begin. When the
transaction is completed then it releases all the lock.

• If all the locks are not granted then this protocol allows the transaction to rolls back and waits
until all the locks are granted
3. Two-phase locking (2PL)

•The two-phase locking protocol divides the execution phase of the transaction into
three parts.

•In the first part, when the execution of the transaction starts, it seeks permission for
the lock it requires.

•In the second part, the transaction acquires all the locks. The third phase is started as
soon as the transaction releases its first lock.

•In the third phase, the transaction cannot demand any new locks. It only releases the
acquired locks.
A transaction is said to follow the Two-Phase Locking protocol if Locking and Unlocking
can be done in two phases.

•Growing Phase: New locks on data items may be acquired but none can be released.
•Shrinking Phase: Existing locks may be released but no new locks can be acquired.

Note: If lock conversion is allowed, then upgrading of lock( from S(a) to X(a) ) is
allowed in the Growing Phase, and downgrading of lock (from X(a) to S(a)) must be
done in the shrinking phase.
Lock Point
The Point at which the growing phase ends, i.e., when a transaction takes the final
lock it needs to carry on its work.

Transaction T1:

Growing phase: from step 1-3


Shrinking phase: from step 5-7
Lock point: at 3

Transaction T2:

Growing phase: from step 2-6


Shrinking phase: from step 8-9
Lock point: at 6
4. Strict Two-phase locking (Strict-2PL)

The first phase of Strict-2PL is similar to 2PL. In the first phase, after acquiring all the locks, the
transaction continues to execute normally.

The only difference between 2PL and strict 2PL is that Strict-2PL does not release a lock after
using it.
Strict-2PL waits until the whole transaction to commit, and then it releases all the locks at a
time.
Strict-2PL protocol does not have shrinking phase of lock release.

It does not have cascading abort as 2PL does


Timestamp Ordering Protocol

• The Timestamp Ordering Protocol is used to order the transactions based on their
Timestamps. The order of transaction is nothing but the ascending order of the transaction
creation.

• The priority of the older transaction is higher that's why it executes first. To determine the
timestamp of the transaction, this protocol uses system time or logical counter.

• The lock-based protocol is used to manage the order between conflicting pairs among
transactions at the execution time. But Timestamp based protocols start working as soon as
a transaction is created.

• Let's assume there are two transactions T1 and T2. Suppose the transaction T1 has entered
the system at 007 times and transaction T2 has entered the system at 009 times. T1 has the
higher priority, so it executes first as it is entered the system first.

• The timestamp ordering protocol also maintains the timestamp of last 'read' and 'write'
operation on a data.
1. Check the following condition whenever a transaction Ti issues a Read
(X) operation:

•If W_TS(X) >TS(Ti) then the operation is rejected.


•If W_TS(X) <= TS(Ti) then the operation is executed.
•Timestamps of all the data items are updated.

2. Check the following condition whenever a transaction Ti issues


a Write(X) operation:

•If TS(Ti) < R_TS(X) then the operation is rejected.


•If TS(Ti) < W_TS(X) then the operation is rejected and Ti is rolled back otherwise
the operation is executed.

Where:

TS(TI) denotes the timestamp of the transaction


Ti.
R_TS(X) denotes the Read time-stamp of data-
item X.
W_TS(X) denotes the Write time-stamp of data-

You might also like