Lock-based protocols in DBMS Theory - Step-by-Step Execution

Concept Flow - Lock-based protocols

Transaction requests lock

↓

Is lock available?

No→Wait until lock is free

Yes↓

Lock granted

↓

Transaction performs operations

↓

Transaction releases lock

↓

Other waiting transactions notified

↓

Transaction requests lock

This flow shows how transactions request locks, wait if needed, perform operations, and release locks to ensure safe data access.

Execution Sample

DBMS Theory

Transaction T1 requests lock on DataItem A
Lock is free, T1 granted lock
T1 reads and writes DataItem A
T1 releases lock on DataItem A
Transaction T2 requests lock on DataItem A
Lock is free, T2 granted lock

This example traces two transactions requesting and releasing locks on the same data item sequentially.

Analysis Table

Step	Transaction	Action	Lock Status on DataItem A	Result
1	T1	Requests lock	Free	Lock granted to T1
2	T1	Reads/Writes DataItem A	Locked by T1	Operation successful
3	T1	Releases lock	Locked by T1	Lock released, now free
4	T2	Requests lock	Free	Lock granted to T2
5	T2	Reads/Writes DataItem A	Locked by T2	Operation successful

💡 No more transactions requesting lock; process ends

State Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5
Lock Status on DataItem A	Free	Locked by T1	Locked by T1	Free	Locked by T2	Locked by T2

Key Insights - 2 Insights

Why does Transaction T2 have to wait if T1 holds the lock?

Because the lock is exclusive, only one transaction can access the data item at a time. As shown in step 1 and 4, T2 can only get the lock after T1 releases it in step 3.

What happens if a transaction tries to access data without a lock?

It risks reading or writing inconsistent data. Lock-based protocols prevent this by granting locks before access, as seen in the execution table where operations happen only after lock is granted.

Visual Quiz - 3 Questions

Look at the execution table, what is the lock status on DataItem A after step 3?

A Locked by T1

B Free

C Locked by T2

D Waiting

💡 Hint

Check the 'Lock Status on DataItem A' column at step 3 in the execution_table

At which step does Transaction T2 get the lock on DataItem A?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look for when T2 requests and is granted the lock in the execution_table

If Transaction T1 did not release the lock at step 3, what would happen to Transaction T2's request?

A T2 would get the lock immediately

B T2 would abort its operation

C T2 would wait until the lock is released

D T2 would share the lock with T1

💡 Hint

Refer to the concept_flow where transactions wait if the lock is not free

Concept Snapshot

Lock-based protocols control access to data by granting locks to transactions.
Only one transaction can hold an exclusive lock on a data item at a time.
Transactions must wait if the lock is held by another.
Locks are released after operations to allow others access.
This ensures data consistency and prevents conflicts.

Full Transcript

Lock-based protocols manage how multiple transactions access the same data safely. When a transaction wants to use a data item, it requests a lock. If the lock is free, it is granted immediately. If not, the transaction waits. After finishing its operations, the transaction releases the lock, allowing others to proceed. This process prevents conflicts and keeps data consistent. The execution table shows two transactions, T1 and T2, accessing the same data item sequentially by acquiring and releasing locks. Key points include waiting for locks and exclusive access. Understanding this flow helps ensure safe database operations.

Practice

1. What is the main purpose of lock-based protocols in a database management system?

easy

A. To control concurrent access to data and prevent conflicts

B. To speed up database queries by caching results

C. To backup data automatically at regular intervals

D. To encrypt data for security purposes

Solution

1. Step 1: Understand the role of lock-based protocols

   Lock-based protocols manage how multiple users access data simultaneously to avoid conflicts.

2. Step 2: Identify the main goal

   The main goal is to control concurrent access and maintain data consistency.

3. Final Answer:

   To control concurrent access to data and prevent conflicts -> Option A

4. Quick Check:

   Lock-based protocols = control access [OK]

Hint: Locks manage who reads/writes data safely [OK]

Common Mistakes:

• Confusing locking with data backup
• Thinking locks speed up queries
• Mixing locking with encryption

2. Which of the following is the correct syntax to request a shared lock on a data item X in a lock-based protocol?

easy

A. lock_shared(X)

B. lock(X, shared)

C. lock_exclusive(X)

D. lock(X, exclusive)

Solution

1. Step 1: Understand shared lock syntax

   Shared locks allow multiple readers and are usually requested with a 'shared' parameter.

2. Step 2: Identify correct syntax format

   Among options, lock(X, shared) correctly requests a shared lock on X.

3. Final Answer:

   lock(X, shared) -> Option B

4. Quick Check:

   Shared lock syntax = lock(X, shared) [OK]

Hint: Shared lock uses 'shared' keyword in lock call [OK]

Common Mistakes:

• Using exclusive lock syntax for shared lock
• Confusing function names
• Omitting lock type parameter

3. Consider two transactions T1 and T2 accessing data item A. T1 requests a shared lock on A, then T2 requests an exclusive lock on A. What will happen next?

medium

A. Both T1 and T2 will hold locks simultaneously

B. T2 will immediately get the exclusive lock

C. T1 will be aborted due to conflict

D. T2 will wait until T1 releases the shared lock

Solution

1. Step 1: Analyze lock compatibility

   Shared locks allow multiple readers, but exclusive locks require exclusive access.

2. Step 2: Understand lock waiting rules

   T2's exclusive lock request conflicts with T1's shared lock, so T2 must wait until T1 releases the lock.

3. Final Answer:

   T2 will wait until T1 releases the shared lock -> Option D

4. Quick Check:

   Exclusive lock waits for shared lock release [OK]

Hint: Exclusive lock waits if shared lock exists [OK]

Common Mistakes:

• Assuming exclusive lock is granted immediately
• Thinking both locks can coexist
• Believing transaction abort happens automatically

4. A transaction T tries to acquire an exclusive lock on data item B but the system throws a deadlock error. What is the most likely cause?

medium

A. T is waiting for another transaction holding a conflicting lock on B

B. T requested a shared lock instead of exclusive lock

C. T has already released all its locks

D. The data item B does not exist in the database

Solution

1. Step 1: Understand deadlock in locking

   Deadlock occurs when two or more transactions wait indefinitely for locks held by each other.

2. Step 2: Identify cause of deadlock error

   T's exclusive lock request is blocked because another transaction holds a conflicting lock, causing deadlock.

3. Final Answer:

   T is waiting for another transaction holding a conflicting lock on B -> Option A

4. Quick Check:

   Deadlock = waiting on conflicting locks [OK]

Hint: Deadlock means waiting on each other's locks [OK]

Common Mistakes:

• Confusing deadlock with syntax errors
• Assuming deadlock means missing data
• Thinking deadlock occurs if locks are released

5. In a system using strict two-phase locking (2PL), which of the following is true about when locks are released?

hard

A. Locks are released randomly during the transaction

B. Locks are released immediately after each data item is accessed

C. All locks are released only after the transaction commits or aborts

D. Shared locks are released before exclusive locks

Solution

1. Step 1: Understand strict two-phase locking

   Strict 2PL requires holding all locks until the transaction finishes (commit or abort) to ensure serializability.

2. Step 2: Identify lock release timing

   Locks are not released during the transaction but only after it ends, preventing conflicts.

3. Final Answer:

   All locks are released only after the transaction commits or aborts -> Option C

4. Quick Check:

   Strict 2PL releases locks after commit/abort [OK]

Hint: Strict 2PL holds locks until transaction ends [OK]

Common Mistakes:

• Releasing locks too early during transaction
• Confusing strict 2PL with basic locking
• Assuming random lock release