Chapter 4

Concurrency Control Trchnique

 Introduction
• Transaction Processor is divided into:
– A concurrency-control manager (scheduler)- responsible
for assuring isolation of transactions
– A logging and recovery manager- responsible for the
durability of transactions.
• The scheduler (concurrency-control manager) must assure
that the individual actions of multiple transactions are
executed in such an order that the net effect is the same as if
the transactions had in fact executed one-at-a-time.

Requests from
transactions

Lock Scheduler
Table
Read and Writes

Buffers 2
 Introduction…
The Purpose of Concurrency Control is:
– 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.
• A typical scheduler does its work by maintaining locks on certain
pieces of the database.
• These locks prevent two transactions from accessing the same
piece of data at the same time. 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 data item A and if the other
transaction is rolled-back or waits.

3
 Introduction…

Example:
Bank database: 3
Accounts A = 500
Account B = 500
Balance
s C = 500

Property: A + B + C = 1500

Money does not leave the system

4
 Introduction …

Example
Transaction T1: Transfer Transaction T2: Transfer
100 from A to B 100 from A to C
Read (A) Read (A)
A = A - 100 A= A - 100
Write (A) Write (A)
Read (B) Read (C)
B = B+ 100 C = C + 100
Write (B) Write (C)
5
 Transaction T1 Transaction T2 A B C

500 500 500

Read (A)
A= A - 100
Read (A)
A = A- 100
Write (A) 400 500 500

Write (A) 400 500 500

Read (B)
B= B+ 100
Write (B) 400 600 500

Read (C)
C= C + 100
Write (C) 400 600 600
Schedule 6
400 + 600 + 600 = 1600
 Transaction T1 Transaction T2 A B C

500 500 500

Read (A)
A= A - 100
Write (A) 400 500 500
Read (A)
A= A - 100
Write (A) 300 500 500
Read (B)
B = B + 100
Write (B) 300 600 500

Read (C)
C= C+ 100
Alternative Write (C) 300 600 600
Schedule
300 + 600 + 600 = 1500 7
So What ?
 Concurrency Control Techniques

• Concurrency control techniques are used to ensure the

noninterference or isolation property of concurrently executing
transactions.
• Basic concurrency control techniques are:
– Locking
– Time stamping
– Multi version
– Optimistic methods(Validation or Certification)

– Lock Granularity
8
 Locking
⚫ Lock is a variable associated with a data item that describes the

status of the data item with respect to the possible operations that
can be applied to it.
⚫ Generally, a transaction must claim a shared (read) or exclusive

(write) lock on a data item before read or write.

⚫ Lock prevents another transaction from modifying item or even

reading it, in the case of a write lock.

⚫ A binary lock can have two states or values: locked and unlocked

(or 1 and 0, for simplicity).

9
 Cont....
– Locking is an operation which secures

(a) permission to Read

(b) permission to Write a data item for a transaction.

• 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.
• Example:
• Unlock (X): Data item X is made available to all other
 Cont…
▪ Two lock 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.
▪ Conflict matrix

11
 Cont …
▪ Lock Manager:
• Keep track of and control access to locks on data items.
▪ Lock table:
• Lock manager uses it to store the identity of a 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.

▪ 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. 12
 Locking - Basic Rules

• It has two oprerations : Lock_item(X) and unLock_item(X)

• A transaction request access to an item X by first issuing a

lock_Item(x) opreation .
• If lock (x)=1, the transaction is forced to wait.
• If lock (X)= 0; it is set to 1 and the transaction is allowed to access
x
• When a transaction finished operation on X it issues an
Unlock_Item operation which set lock(x) to 0 so that X may be
accessed by another transaction
13
 Cont...

• If transaction has shared lock on item, it can read but not update
item.
• If transaction has exclusive lock on item, it can both read and
update item.
• Reads cannot conflict, so more than one transaction can hold shared
locks simultaneously on same item.
• Exclusive lock gives transaction exclusive access to that item.
 Locking …
• The following code performs the read • The following code performs
operation: read_lock(X): the write lock operation:
B: if LOCK (X) = “unlocked” then write_lock(X):
begin
LOCK (X) ← “read-locked”; B: if LOCK (X) =
no_of_reads (X) ← 1; “unlocked” then
end
else if LOCK (X) ← “read-locked” then
LOCK (X) ←
no_of_reads (X) ← no_of_reads (X) “write-locked”;
+1 else
else begin
wait (until LOCK (X) = “unlocked” wait (until LOCK(X)
and = “unlocked”
the lock manager wakes up the
transaction); and the lock
go to B manager wakes up the
end; transaction);
goto B
15
end;
 Two-Phase Locking Techniques:
• Every transaction can be divided into Two Phases: Locking
(Growing) & Unlocking (Shrinking)
– Locking (Growing) Phase:
• A transaction applies locks (read or write) on desired data
items one at a time.
• acquires all locks but cannot release any locks.
– Unlocking (Shrinking) Phase:
• A transaction unlocks its locked data items one at a time.
• Releases locks but cannot acquire any new locks.
• .
16
 Cont...
• 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 must not
begin

# locks
held by
Ti

Growing Phase Shrinking Phase Time

▪Transaction follows 2PL protocol if all locking operations precede

first unlock operation in the transaction.
 Cont…

Example
T1 T2 Result
read_lock (Y); read_lock (X); Initial values: X=20; Y=30
read_item (Y); read_item (X); Result of serial execution
unlock (Y); unlock (X); T1 followed by T2
write_lock (X); Write_lock (Y); X=50, Y=80.
read_item (X); read_item (Y);
Result of serial execution
X:=X+Y; Y:=X+Y;
write_item (X); write_item (Y); T2 followed by T1
unlock (X); unlock (Y); X=70, Y=50

• The transactions do not follow two-phase locking.

18
 cont…
T1 T2
read_lock (Y);
read_item (Y);
unlock (Y);
read_lock (X);
read_item (X); Result
unlock (X); X=50; Y=50
write_lock (Y);
read_item (Y); Nonserializable
Y:=X+Y; because it violated
write_item (Y); two-phase policy.
unlock (Y);
write_lock (X);
read_item (X);
X:=X+Y;
write_item (X);
Tim unlock (X);
e

19
 Cont..…

T’1 T’2
read_lock (Y); read_lock (X);
read_item (Y); read_item (X);
write_lock (X); Write_lock (Y); T’1 and T’2 follow
two-phase
unlock (Y); unlock (X); . policy but they are subject
read_item (X); read_item (Y); to
X:=X+Y; Y:=X+Y; deadlock, which must be
dealt with
write_item (X); write_item (Y);
unlock (X); unlock (Y);
• If every transaction in the schedule follows the 2PL protocol , the
schedule is guaranteed to be serializabe
• Limitation
– It may limit the amount of concurrency control that can occur
20 in
the schedule . How?
 Dealing with Deadlock and Starvation

• Remark:
– 2PL protocol guarantees serialzability but it doesn’t permit all the
possible serializability schedule
– The use of this locking can cause two additional problems
• Deadlock
• Starvation

21
 Cont...
⚫ Deadlock
⚫ It is a state that may result when two or more transactions
are each waiting for locks held by the other to be released
⚫ Example : ⚫ T1 is in the waiting queue for
X which is locked by T2
T1 T2
⚫ T2 is on the waiting queue for
read_lock (Y); Y which is locked by T1
read_item (Y); ⚫ No transaction can continue
read_lock (X); until the other transaction
read_item (X); completes
write_lock (X); ⚫ T1 and T2 did follow
write_lock (Y); two-phase policy but they are
deadlock
⚫ So the DBMS must either
prevent or detect and resolve
such deadlock situations
 Cont…

• There are possible solutions : Deadlock prevention, deadlock

detection and avoidance, and lock timeouts
i. Deadlock prevention protocol: two possibilities
▪ The conservative two-phase locking
− 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.
− Limitation : It restricts concurrency
23
 Cont....
▪ Transaction Timestamp( TS(T) )

▪ We can prevent deadlocks by giving each transaction a priority

and ensuring that lower priority transactions are not allowed to
wait for higher priority transactions.
▪ One way to assign priorities is to give each transaction a
timestamp when it starts up.
▪ it is a unique identifier given to each transaction based on time
in which it is started. i.e if T1 starts before T2 , TS(T1)<TS(T2)
▪ The lower the timestamp, the higher the transaction's priority,
that is, the oldest transaction has the highest priority.
 Cont....
Deadlock and Starvation …
ii. Deadlock Detection and resolution
– In this approach, deadlocks are allowed to happen
– The scheduler maintains a wait-for-graph for detecting cycle.
– When a chain like: Ti waits for Tj waits for Tk waits for Ti or Tj
occurs, then this creates a cycle.
– When the system is in the state of deadlock , some of the
transaction should be aborted by selected (victim) and
rolled-back
– This can be done by aborting those transaction: that have made
the least work, the one with the lowest locks, and that have the
least # of abortion and so on
– Example:

25
 Cont …
iii. Timeouts
• It uses the period of time that several transaction have been waiting
to lock items
• It has lower overhead cost and it is simple
• If the transaction wait for a longer time than the predefined time out
period, the system assume that may be deadlocked and aborted it
▪ Starvation
• Starvation occurs when a particular transaction consistently waits or
restarted and never gets a chance to proceed further while other
transaction continue normally
• This may occur , if the waiting method for item locking:
– Gave priority for some transaction over others
– Problem in Victim selection algorithm- it is possible that the same
transaction may consistently be selected as victim and rolled-back.
– Solution
• FIFO
• Allow for transaction that wait for a longer time 26
• Give higher priority for transaction that have been aborted for
 Timestamp based concurrency control algorithm
• Timestamp
– In lock based concurrency control , conflicting actions of different
transactions are ordered by the order in which locks are obtained.
– But here, Timestamp values are assigned based on time in which
the transaction are submitted to the system using the current date
& time of the system
– 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. 27
 Cont....
– It doesn’t use lock, thus deadlock cannot be occurred

– In the timestamp ordering, conflicting operation in the schedule

shouldn’t violate serilazable ordering
– This can be achieved by associating timestamp value (TS) to each
database item which is denoted as follow:

b) Read_Ts(x): the read timestamp of x – this is the largest time

among all the time stamps of transaction that have successfully
read item X
c) Write_TS(X): the largest of all the timestamps of transaction that
have successfully written item X
 Multiversion 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.
– This algorithm uses the concept of view serilazability than
conflict serialiazability
– 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 29
is
 Validation (Optimistic) Concurrency Control
– This technique allow transaction to proceed asynchronously and
only at the time of commit, serializability is checked &
– transactions are aborted in case of non-serializable schedules.
– Good if there is little interference among transaction
– It has three phases: Read, Validation , and Write phase

i. Read phase:
– A transaction can read values of committed data items.
However, updates are applied only to local copies (versions) of
the data items (in database cache).
30
 Cont..
• ii. Validation phase:.

− If the transaction Ti decides that it wants to commit, the

DBMS checks whether the transaction could possibly have
conflicted with any other concurrently executing transaction.
− While one transaction ,Ti, is being validated , no other
transaction can be allowed to commit
− This phase for Ti checks that, for each transaction Tj that is
either committed or is in its validation phase, one of the
following conditions holds:
 Cont …

▪ Tj completes its write phase before Ti starts its read phase.

▪ Ti starts its write phase after Tj completes its write phase and the
read set of Ti has no item in common with the write set of Tj

▪ Both the read_set and write_set of Ti have no items in common

with the write_set of Tj, and Tj completes its read phase before
Ti completes its read phase.

32
 Cont....

− When validating Ti, the first condition is checked first for each
transaction Tj, since (1) is the simplest condition to check. If (1)
is false then (2) is checked and if (2) is false then (3 ) is checked.
− If none of these conditions holds, the validation fails and Ti is
aborted.

iii. Write phase:

▪ On a successful validation, transactions’ updates are applied to
the database; otherwise, transactions are restarted.
 Multiple Granularity Locking
▪ A lockable unit of data defines its granularity

▪ Granularity can be coarse (entire database) or it can be fine (an

attribute of a relation).
▪ Example of data item granularity:
▪ A field of a database record

▪ A database record
▪ A disk block/ page
▪ An entire file
▪ The entire database
▪ Data item granularity significantly affects concurrency control 34
 Cont...
▪ Example:

▪ A transaction that expects to access most of the pages in a file

should probably set a lock on the entire file , rather than locking
individual pages or records
▪ If a transaction that requires to access relatively few pages of the
file , it is better to lock those pages
▪ Similarly , if a transaction access several records on a page , it
should lock the entire page and if it access just a few records , it
should lock some those records.
▪ This example will hold true , if a lock on the node locks that node and
implicitly all its descendants
 Cont...

The following diagram illustrates a hierarchy of granularity

from coarse (database) to fine (record).
 Cont....
To manage such hierarchy, in addition to read(S) and write(X), 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 node(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) will be
requested on some descendent nodes(s).
 ! ! ! ! ! !
YO U
N K
THA