Two-Phase Locking (2PL) Protocol in Concurrency Control

 

Two-Phase Locking (2PL) Protocol in Concurrency Control

Two-Phase Locking (2PL) is one of the most important concurrency control protocols in a DBMS.
It ensures that concurrent transaction schedules are serializable, meaning they produce the same result as some serial execution.

The protocol controls when locks can be acquired and when they can be released during a transaction.

1. Definition of Two-Phase Locking

A transaction follows the Two-Phase Locking protocol if:

All lock operations (read_lock, write_lock) occur before the first unlock operation.

In other words, a transaction must finish acquiring all locks before it starts releasing any lock.

2. Two Phases of Two-Phase Locking

Every transaction executing under 2PL has two distinct phases.

PhaseDescription
Growing Phase            Transaction can acquire locks but cannot release any
Shrinking Phase            Transaction can release locks but cannot acquire new locks

1. Growing Phase (Expanding Phase)

During this phase:

  • The transaction acquires locks on required data items

  • No locks are released

Example:

read_lock(X)
write_lock(Y)
read_lock(Z)

Locks are only added in this phase.

2. Shrinking Phase

During this phase:

  • The transaction releases locks

  • No new locks can be acquired

Example:

unlock(Z)
unlock(Y)
unlock(X)

Once the transaction releases its first lock, it enters the shrinking phase permanently.

3. Lock Conversion Rules in 2PL

If lock conversion is allowed, it must follow strict rules.

Lock Upgrading

Changing a read lock → write lock

read_lock(X)
write_lock(X)

This must occur in the growing phase.

Lock Downgrading

Changing a write lock → read lock

write_lock(X)
read_lock(X)

This must occur in the shrinking phase.

4. Why Two-Phase Locking is Needed

Simple locking does not guarantee serializability.

Problem example:

  • Transaction T1 unlocks Y too early

  • Transaction T2 unlocks X too early

This allows interleaving that produces a nonserializable schedule, leading to incorrect results.

Two-Phase Locking prevents this by forcing transactions to finish locking before unlocking.





5. Guarantee of Serializability

If every transaction in a schedule follows the Two-Phase Locking protocol, then:

  • The schedule is guaranteed to be conflict serializable

  • There is no need to test serializability separately

Thus, the protocol itself ensures correctness.

6. Limitations of Two-Phase Locking

Although 2PL guarantees serializability, it introduces some limitations.

1. Reduced Concurrency

A transaction may have to keep locks longer than necessary.

Example:

  • Transaction finishes using item X

  • But it cannot release X yet because it still needs to lock Y

This forces other transactions waiting for X to wait longer.

2. Some Serializable Schedules Are Disallowed

Even though a schedule might be serializable, 2PL may not allow it.

Thus, 2PL is correct but restrictive.

7. Variants of Two-Phase Locking

There are several variations of the 2PL protocol designed to improve performance or avoid problems like deadlocks.

1. Basic Two-Phase Locking (Basic 2PL)

This is the standard form of the protocol.

Rules:

  • Transaction follows growing phase and shrinking phase

  • Locks can be released anytime during shrinking phase

Characteristics:

  • Guarantees conflict serializability

  • May still cause deadlocks

2. Conservative Two-Phase Locking (Static 2PL)

In this variation:

  • A transaction locks all required data items before it begins execution

The transaction must declare:

  • Read-set → items it will read

  • Write-set → items it will write

Example:

Lock all required items
Start transaction execution

If any item cannot be locked:

  • The transaction does not start

  • It waits until all items become available.

Advantage

  • Deadlock-free

Because all locks are acquired at the beginning.

Disadvantage

  • Requires knowing all items needed before execution

  • Not always possible in practice.

3. Strict Two-Phase Locking (Strict 2PL)

This is the most commonly used protocol in real DBMS systems.

Rule:

A transaction cannot release any write (exclusive) lock until it commits or aborts.

Thus:

  • Write locks are held until transaction completion

Advantages

  • Prevents cascading rollbacks

  • Produces strict schedules

  • Improves recoverability

Disadvantage

  • Deadlocks can still occur

4. Rigorous Two-Phase Locking (Rigorous 2PL)

This is a stricter version of Strict 2PL.

Rule:

A transaction does not release any lock (read or write) until it commits or aborts.

Thus:

  • Both shared locks and exclusive locks are held until completion.

Advantages

  • Guarantees strict schedules

  • Easier to implement

Disadvantage

  • Even less concurrency compared to strict 2PL.

8. Comparison of 2PL Variants

VariantLock Release RuleDeadlockConcurrency
Basic 2PL    Locks released in shrinking phase    Possible    Moderate
Conservative 2PL    All locks acquired before start    No deadlock    Lower
Strict 2PL    Write locks held until commit    Possible    Moderate
Rigorous 2PL    All locks held until commit    Possible    Lowest

9. How the DBMS Implements 2PL

Usually the concurrency control subsystem automatically issues lock requests.

Example:

If transaction executes:

read_item(X)

The system automatically performs:

read_lock(X)
read_item(X)

Similarly:

write_item(X)

becomes

write_lock(X)
write_item(X)

The system checks the lock table:

  • If the item is locked → transaction waits

  • If available → lock is granted

The lock table is then updated accordingly.

10. Problems of Lock-Based Concurrency Control

Locking introduces two major problems.

1. Deadlock

Two transactions wait for each other’s locks.

Example:

T1 holds X and waits for Y
T2 holds Y and waits for X

2. Starvation

A transaction waits indefinitely because other transactions keep getting priority.

Final Summary

Two-Phase Locking is a locking protocol that guarantees serializability of schedules.

Key points:

  • Transactions have two phases: growing and shrinking.

  • Locks are acquired first and released later.

  • It ensures conflict serializable schedules.

Main variants:

  • Basic 2PL – standard form

  • Conservative 2PL – locks all items before starting

  • Strict 2PL – holds write locks until commit

  • Rigorous 2PL – holds all locks until commit

Two-phase locking is one of the most widely used concurrency control techniques in database systems.

Comments

Post a Comment

Popular posts from this blog

Database Management Systems DBMS PCCST402 Semester 4 KTU CS 2024 Scheme

 About Me Database Management Systems DBMS PCCST402 Scheme and Syllabus Model Question Paper - KTU BTech DBMS PCCST402 2024 Scheme Module-1 Introduction to DBMS Introduction to DBMS Example  Database Database System Vs Traditional File Processing Advantages of using DBMS Database System Concepts and Architecture Data Models, Schemas and Instances   Three schema architecture and Data Independence Database Languages and Interfaces Centralized and Client Server Architectures in DBMS Classification of Database Management Systems Conceptual Data Modeling and Database Design Conceptual Modeling and the Role of the ER Model in Database Design Entities and Attributes  Company Database Application - Example Entity Types, Entity Sets, Keys, and Value Sets in the ER Model Initial Conceptual Design of the COMPANY Database Relationship Types in the ER Model Relationship Degree, Role Names, and Recursive Relationships Constraints on Binary Relationship Types Attributes of Relation...
Read more

Data Models, Schemas and Instances

  Data Models, Schemas and Instances  1. Data Abstraction In databases, data abstraction means hiding the complex details of how data is stored and focusing only on what is important. Different users can view data at different levels of detail depending on their needs. 2. Data Models A data model is a collection of concepts used to describe the structure of a database. It defines: Data types Relationships among data Constraints on data Operations for accessing and updating data Data models help us understand and design databases without worrying about low-level storage details. Categories of Data Models a) High-level / Conceptual Data Models Close to how users think about data. Use concepts like entities , attributes , and relationships . Example: ER (Entity–Relationship) Model . b) Representational (Implementation) Data Models In between conceptual and physical models. Easy for users to understand but still close to how data is st...
Read more

Introduction to Database Management System -DBMS

Image
In today’s digital world, almost every application—from mobile banking and e-commerce to university portals and hospital systems—depends on the efficient storage, organization, and retrieval of data. As the amount of information generated by individuals and organizations continues to grow, managing this data in a structured and meaningful way becomes essential. This is where database systems play a central role. A database can be thought of as a well-organized collection of related data, designed so that it can be easily accessed, managed, and updated. But the database itself is only one component. To manage it effectively, we rely on a specialized software package known as a Database Management System (DBMS) . A DBMS provides a systematic and automated way to store large volumes of data, enforce rules for consistency and correctness, protect data from unauthorized access, and allow multiple users to work with the data simultaneously without conflicts. A database typically has three...
Read more