Lock-Based Protocol 편집하기

'''Lock-Based Protocol''' is a concurrency control mechanism in database systems that ensures transaction isolation by managing access to data items through locks. Locks prevent simultaneous transactions from interfering with each other, ensuring data consistency and serializability.
==Key Concepts==
*'''Lock:''' A mechanism that restricts access to a data item for concurrent transactions.
*'''Lock Modes:'''
**'''Shared Lock (S):''' Allows multiple transactions to read a data item but prevents writes.
**'''Exclusive Lock (X):''' Allows a single transaction to read or write a data item.

*'''Compatibility Matrix:''' Defines which lock modes can coexist without conflict.
===Lock Compatibility Matrix===
The following table illustrates the compatibility of different lock modes:
{| class="wikitable"
! !!Shared (S)!!Exclusive (X)
|-
|Shared (S)||Yes||No
|-
|Exclusive (X)||No||No
|}
==Types of Lock-Based Protocols==
Lock-based protocols are classified into several types based on their functionality and guarantees:
#'''Simple Locking Protocol:'''
#*Ensures that transactions acquire locks before accessing data and release them after use.
#*Does not guarantee serializability.

#'''Two-Phase Locking (2PL):'''
#*Divides transaction execution into growing and shrinking phases.
#*Guarantees serializability but may lead to deadlocks.

#'''Strict Two-Phase Locking:'''
#*Holds all locks until the transaction commits or aborts.
#*Prevents cascading rollbacks and ensures recoverability.

#'''Rigorous Two-Phase Locking:'''
#*Holds all locks (shared and exclusive) until the transaction commits.
#*Provides the strictest guarantees.

#'''Hierarchical Locking:'''
#*Uses locks at multiple levels of granularity, such as records, pages, or tables.
#*Requires intention locks to indicate locking at lower levels.
==Example of Lock-Based Protocol==
Consider two transactions, T1 and T2, accessing a shared data item A:
{| class="wikitable"
!Step!!Transaction T1!!Transaction T2!!Explanation
|-
|1||BEGIN TRANSACTION||BEGIN TRANSACTION||Both transactions start.
|-
|2||READ(A)||-||T1 acquires a shared lock on A and reads its value.
|-
|3||-||WRITE(A)||T2 waits because T1 holds a shared lock on A.
|-
|4||WRITE(A)||-||T1 upgrades to an exclusive lock and writes to A.
|-
|5||COMMIT||-||T1 releases its lock, allowing T2 to proceed.
|}
==Deadlocks in Lock-Based Protocols==
Deadlocks occur when two or more transactions are waiting for each other's locks, resulting in a cycle of dependencies. Common strategies to handle deadlocks include:
*'''Deadlock Detection:''' Use a wait-for graph to identify and resolve cycles.
*'''Deadlock Prevention:''' Ensure transactions acquire locks in a predefined order.
*'''Timeouts:''' Abort transactions that wait too long for a lock.
==Advantages==
*'''Data Integrity:''' Ensures that concurrent transactions do not produce inconsistent results.
*'''Serializability Guarantee:''' Most lock-based protocols ensure serializability.
*'''Flexibility:''' Supports various locking mechanisms and levels of granularity.
==Limitations==
*'''Deadlocks:''' Risk of deadlocks due to cyclic dependencies between transactions.
*'''Performance Overhead:''' Managing locks increases system overhead.
*'''Reduced Concurrency:''' High contention for locks may limit parallelism.
==Applications==
Lock-based protocols are widely used in:
*'''Relational Databases:''' To ensure consistency and isolation in multi-user environments.
*'''Distributed Systems:''' Managing concurrency across distributed nodes.
*'''Enterprise Systems:''' Preventing data anomalies in transactional systems.
==See Also==
*[[Concurrency Control]]
*[[Two-Phase Locking]]
*[[Deadlock Detection]]
*[[Transaction Management]]
*[[Hierarchical Locking]]
*[[Multiversion Concurrency Control]]
[[Category:Database]]