Chapter 4

Concurrency Control Techniques

 Concurrency control is used to ensure the noninterference or

isolation property of concurrently executing transactions.
 Purpose of Concurrency Control
 To enforce Isolation (through mutual exclusion) among conflicting
transactions.
 To preserve database consistency through consistency preserving
execution of transactions.
 To resolve read-write and write-write conflicts.
 Example:
 In concurrent execution environment if T1 conflicts with T2 over a
data item A, then the existing concurrency control decides if T1 or
T2 should get the A and if the other transaction is rolled-back or
waits. Prepared by Elisaye B. @WSU-DTC 1
 Various concurrency control
techniques are:
1. Two-phase locking Protocol
2. Time stamp ordering Protocol
3. Multi version concurrency control
4. Validation (Optimistic) concurrency
control
5. Granularity of data items and
Multiple Granularity Locking
Prepared by Elisaye B. @WSU-DTC 2
 1. Two-Phase Locking Protocol:
 Locking is an operation which secures: permission to read, OR
permission to write a data item.
 Two phase locking is a process used to gain ownership of shared
resources without creating the possibility of deadlock.
 The 3 activities taking place in the two phase update algorithm
are:
(i). Lock Acquisition
(ii). Modification of Data
(iii). Release Lock
 Example:
 Lock (X). Data item X is locked in behalf of the requesting
transaction.
 Unlocking is an operation which removes these permissions from the
data item.
 Unlock (X): Data itemPrepared by Elisaye B. @WSU-DTC 3
X is made available to all other transactions.
Two-Phase Locking Techniques: Essential
components

Two locks modes:

(a) shared (read) (b) exclusive (write).

Shared mode: shared lock (X)

More than one transaction can apply share lock
on X for reading its value but no write lock can
be applied on X by any other transaction.

Exclusive mode: Write lock (X)

Only one write lock on X can exist at any time
and no shared lock can be applied by any other
transaction on X.
Read Write

Conflict matrix
Read Y N

N N
Writ

Prepared by Elisaye B. @WSU-DTC 4

Two-Phase Locking Techniques: Essential
components
 Lock Manager:

Managing locks on data items.
 Lock table:

Lock manager uses it to store the identify of
transaction locking a data item, the data item, lock
mode and pointer to the next data item locked. One
simple way to implement a lock table is through
linked list.
Transaction ID Data item id lock mode Ptr to next data item
T1 X1 Read Next
Prepared by Elisaye B. @WSU-DTC 5
Two-Phase Locking Techniques: Essential
components
 Database requires that all transactions should be
well-formed. A transaction is well-formed if:

It must lock the data item before it reads or
writes to it.

It must not lock an already locked data items
and it must not try to unlock a free data item.

Prepared by Elisaye B. @WSU-DTC 6

Two-Phase Locking Techniques: Essential components
 The following code performs the lock operation:

B: if LOCK (X) = 0 (*item is unlocked*)

then LOCK (X)  1 (*lock the item*)
else begin
wait (until lock (X) = 0) and
the lock manager wakes up the transaction);
goto B
end;
 The following code performs the unlock operation:
LOCK (X)  0 (*unlock the item*)
if any transactions are waiting then
wake up one of the waiting the transactions;
Prepared by Elisaye B. @WSU-DTC 7
  The following code performs the read operation:
B: if LOCK (X) = “unlocked” then
begin LOCK (X)  “read-locked”;
no_of_reads (X)  1;
end
else if LOCK (X)  “read-locked” then
no_of_reads (X)  no_of_reads (X) +1
else begin wait (until LOCK (X) = “unlocked” and
the lock manager wakes up the transaction);
go to B
end;
 The following code performs the write lock operation:
B: if LOCK (X) = “unlocked” then
begin LOCK (X)  “write-locked”;
no_of_writes (X)  1;
end
else if LOCK (X)  “write-locked” then
no_of_writes (X)  no_of_write (X) +1
else begin wait (until LOCK (X) = “unlocked” and
the lock manager wakes up the transaction);
Prepared by Elisaye B. @WSU-DTC 8
go to B

The following code performs the unlock
operation:
if LOCK (X) = “write-locked” then
begin LOCK (X)  “unlocked”;
wakes up one of the transactions, if any
end
else if LOCK (X)  “read-locked” then
begin
no_of_reads (X)  no_of_reads (X) -1
if no_of_reads (X) = 0 then
begin
LOCK (X) = “unlocked”;
wake up one of the transactions, if any
end
end; Prepared by Elisaye B. @WSU-DTC 9
Two-Phase Locking Techniques: The algorithm
 Two Phases:
 (a) Locking (Growing)

 (b) Unlocking (Shrinking).

 Locking (Growing) Phase:

 A transaction applies locks (read or write) on desired

data items one at a time.

 Unlocking (Shrinking) Phase:
 A transaction unlocks its locked data items one at a

time.
 Requirement:
 For a transaction these two phases must be mutually

exclusively, that is, during locking phase unlocking

phase must not start and during unlocking phase
locking phase mustPrepared
notby begin.
Elisaye B. @WSU-DTC 10
Two-Phase Locking Techniques: The algorithm
 Two-phase policy generates three locking algorithms

(a) Basic

(b) Conservative

(c) strict
 Conservative:

Prevents deadlock by locking all desired data items
before transaction begins execution.
 Basic:

Transaction locks data items incrementally. This may
cause deadlock which is dealt with.
 Strict:

A more stricter version of Basic algorithm where
unlocking is performed after a transaction terminates
(commits or aborts and rolled-back). This is the most
commonly used two-phase locking algorithm.
Prepared by Elisaye B. @WSU-DTC 11
 Dealing with Deadlock and Starvation
 A deadlock is a condition where two or more transactions are
waiting indefinitely for one another to give up locks.
 Deadlock is said to be one of the most feared complications in
DBMS as no task ever gets finished and is in waiting state
forever.
 Starvation or Livelock is the situation when a transaction has
to wait for an indefinite period of time to acquire a lock.
 Reasons for Starvation
 If the waiting scheme for locked items is unfair. ( priority
queue )
 Victim selection (the same transaction is selected as a victim
repeatedly )
 Resource leak.
Prepared by Elisaye B. @WSU-DTC 12
 Deadlock prevention
 A transaction locks all data items it refers to before it
begins execution.
 This way of locking prevents deadlock since a transaction
never waits for a data item.
 The conservative two-phase locking uses this approach.
 Deadlock detection and resolution
 In this approach, deadlocks are allowed to happen. The
scheduler maintains a wait-for-graph for detecting cycle. If
a cycle exists, then one transaction involved in the cycle is
selected (victim) and rolled-back.
 A wait-for-graph is created using the lock table. As soon as
a transaction is blocked, it is added to the graph. When a
chain like: Ti waits for Tj waits for Tk waits for Ti or Tj
occurs, then this creates a cycle. One of the transaction o
Prepared by Elisaye B. @WSU-DTC 13
 Deadlock avoidance
 There are many variations of two-phase locking
algorithm.
 Some avoid deadlock by not letting the cycle to

complete.
 That is as soon as the algorithm discovers that

blocking a transaction is likely to create a cycle,

it rolls back the transaction.
 Wound-Wait and Wait-Die algorithms use

timestamps to avoid deadlocks by rolling-back

victim.
Prepared by Elisaye B. @WSU-DTC 14
 2.Timestamp based concurrency control
algorithm
 Timestamp
 A monotonically increasing variable
(integer) indicating the age of an operation
or a transaction.
 A larger timestamp value indicates a more

recent event or operation.

 Timestamp based algorithm uses

timestamp to serialize the execution of

concurrent transactions.
Prepared by Elisaye B. @WSU-DTC 15
 Basic Timestamp Ordering
 1. Transaction T issues a write_item(X) operation:

If read_TS(X) > TS(T) or if write_TS(X) > TS(T), then an younger
transaction has already read the data item so abort and roll-back T and
reject the operation.

If the condition in part (a) does not exist, then execute write_item(X) of T
and set write_TS(X) to TS(T).
 2. Transaction T issues a read_item(X) operation:

If write_TS(X) > TS(T), then an younger transaction has already written to
the data item so abort and roll-back T and reject the operation.

If write_TS(X)  TS(T), then execute read_item(X) of T and set
read_TS(X) to the larger of TS(T) and the current read_TS(X).
 Strict Timestamp Ordering
 1. Transaction T issues a write_item(X) operation:

If TS(T) > read_TS(X), then delay T until the transaction T’
that wrote or read X has terminated (committed or aborted).
 2. Transaction T issues a read_item(X) operation:

If TS(T) > write_TS(X), then delay T until the transaction16T’
Prepared by Elisaye B. @WSU-DTC
 3. Multi version concurrency control
techniques
 This approach maintains a number of versions
of a data item and allocates the right version to
a read operation of a transaction.
 Thus unlike other mechanisms a read operation

in this mechanism is never rejected.

 Side effect:


Significantly more storage (RAM and disk) is
required to maintain multiple versions.

To check unlimited growth of versions, a
garbage collection is run when some criteria
is satisfied.
Prepared by Elisaye B. @WSU-DTC 17
 Multi version Two-Phase Locking Using
Certify Locks
 Concept

 Allow a transaction T’ to read a data item X

while it is write locked by a conflicting
transaction T.
 This is accomplished by maintaining two

versions of each data item X where one version

must always have been written by some
committed transaction. This means a write
operation always creates a new version of X.
Prepared by Elisaye B. @WSU-DTC 18
 Multiversion Two-Phase Locking Using
Certify Locks
 Note:
 In multiversion 2PL read and write
operations from conflicting transactions
can be processed concurrently.
 This improves concurrency but it may

delay transaction commit because of

obtaining certify locks on all its writes. It
avoids cascading abort but like strict two
phase locking scheme conflicting
transactions may get deadlocked.
Prepared by Elisaye B. @WSU-DTC 19
 4. Validation (Optimistic) Concurrency
Control Schemes
 In this technique only at the time of commit
serializability is checked and transactions are
aborted in case of non-serializable schedules.
 Three phases:
1. Read phase
2. Validation phase
3. Write phase
1. Read phase:
 A transaction can read values of committed data
items. However, updates are applied only to local
copies (versions)Prepared
of the data items (in database 20
by Elisaye B. @WSU-DTC
2. Validation phase: Serializability is
checked before transactions write
their updates to the database.
 This phase for Ti checks that, for

each transaction Tj that is either

committed or is in its validation
phase
3. Write phase: On a successful
validation transactions’ updates are
applied to the database; otherwise,
transactions are restarted
Prepared by Elisaye B. @WSU-DTC 21
 5. Granularity of data items and Multiple Granularity Locking
 A lockable unit of data defines its granularity.
 Data item granularity significantly affects concurrency control performance.
Thus, the degree of concurrency is low for coarse granularity and high for fine
granularity.
 Example of data item granularity:
1. A field of a database record (an attribute of a tuple)
2. A database record (a tuple or a relation)
3. A disk block
4. An entire file
5. The entire database
 To manage such hierarchy of granularity, in addition to read and write, three
additional locking modes, called intention lock modes are defined:
 Intention-shared (IS): indicates that a shared lock(s) will be requested on

some descendent nodes(s).

 Intention-exclusive (IX): indicates that an exclusive lock(s) will be

requested on some descendent node(s).

 Shared-intention-exclusive (SIX): indicates that the current node is locked

in shared mode but an exclusive lock(s)

Prepared by Elisaye will be requested on some
B. @WSU-DTC 22
 The set of rules which must be followed for producing
serializable schedule are
1. The lock compatibility must adhered to.
2. The root of the tree must be locked first, in any mode..
3. A node N can be locked by a transaction T in S or IX
mode only if the parent node is already locked by T in
either IS or IX mode.
4. A node N can be locked by T in X, IX, or SIX mode
only if the parent of N is already locked by T in either
IX or SIX mode.
5. T can lock a node only if it has not unlocked any node
(to enforce 2PL policy).
6. T can unlock a node, N, only if none of the children of
N are currently locked by T.
Prepared by Elisaye B. @WSU-DTC 23