Entries Tagged as 'locking'

Two phase locking

In Databases and Transaction processing, Two phase locking, (2PL) is a concurrency control locking protocol, mechanism, that guarantees Serializability. It is also the name of a class (set) of transaction schedules. Using locks that block processes, 2PL is subject to deadlocks that result from the mutual blocking of two transactions or more.


Two phase locking

According to the Two phase locking protocol, locks are handled by a transaction in two distinct, consecutive phases during the transaction’s execution:

Phase 1: Locks are acquired and no locks are released.

Phase 2: Locks are released and no locks are acquired.

The serializability property is guaranteed for a schedule with transactions that obey the protocol. The 2PL schedule class is defined as the class of all the schedules comprising transactions with data access orders that could be generated by the 2PL protocol.


Strict two phase locking

The Strict two phase locking (S2PL) class of schedules is the intersection of the 2PL class with the class of schedules possessing the Strictness property.

To comply with the S2PL protocol a transaction needs to comply with 2PL, and release its write (exclusive) locks only after it has ended, i.e., being either committed or aborted.

S2PL is a special case of 2PL, i.e., the S2PL class is a proper subclass of 2PL.


Strong strict two phase locking

To comply with the Strong strict two phase locking (SS2PL) protocol a transaction needs to comply with 2PL, and release both its write (exclusive) and read (shared) locks only after it has ended, i.e., being either committed or aborted.
A transaction obeying SS2PL can be viewed as having Phase 1 that lasts its entire execution duration, and no Phase 2 (or degenerate Phase 2). Thus, only one phase is actually left, and “two-phase” in the name seems to be still utilized due to the historical development of the concept from 2PL. The SS2PL property of a schedule is also called Rigorousness, and an SS2PL schedule is also called a Rigorous schedule.

SS2PL is a special case of S2PL, i.e., the SS2PL class of schedules is a proper subclass of S2PL (every SS2PL schedule is also an S2PL schedule, but S2PL schedules exist that are not SS2PL).

SS2PL is the concurrency control protocol of choice for most database systems since it provides besides serializability also Strictness, which is instrumental for efficient database recovery, and also Commitment ordering (CO) for participating in environments where a CO based Global serializability solution is employed.


See also

  • Serializability
  • Lock (computer science)

Tags: Uncategorized by admin
No Comments »

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Tags: Uncategorized by admin
No Comments »

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Tags: Uncategorized by admin
No Comments »

Non-strict two-phase locking

In computer science, non-strict two-phase locking, also 2PL, is a locking method used in concurrent systems.

The rules for 2PL are similar to those of Strict 2PL:

  1. If a transaction T wants to read/write an object, it must request a shared/exclusive lock on the object.
  2. A transaction cannot request additional locks on any object once it releases any lock, and it can release locks at any time (not only at commit time, as in Strict 2PL).

So, every transaction has a growing phase (it acquires locks) and a shrinking phase (it releases locks). 2PL allows only conflict serializable schedules, but doesn’t guarantee that deadlocks will be avoided.

2PL is one scheduling algorithm, sometimes used instead of:

  • simultaneous locking, simultaneous release (Disadvantage: redundant locking, no interactive transactions)
  • incremental locking, simultaneous release (Disadvantage: Deadlock)
  • simultaneous locking, incremental release (Disadvantage: rollback, redundant locking)
  • incremental locking, incremental release (Disadvantage: deadlock, rollback)

Strict two-phase locking

In computer science, strict two-phase locking (Strict 2PL) is a locking method used in concurrent systems.

The two rules of Strict 2PL are:

  1. If a transaction T wants to read/write an object, it must request a shared/exclusive lock on the object.
  2. All exclusive locks held by transaction T are released when T commits (and not before).

Here is an example of Strict 2PL in action with interleaved actions.

<math>

D = \begin{bmatrix}
T1 & T2 \\
S(A) & \\
R(A) & \\ 

      & S(A)   \\
      & R(A)   \\
      & X(B)   \\
      & R(B)   \\
      & W(B)   \\
      & Commit \\

X(C) & \\
R(C) & \\
W(C) & \\
Commit &
\end{bmatrix}
</math>

or in text form:

T1: S(A), R(A); T2: S(A), R(A), X(B), R(B), W(B), Commit; T1: X(C), R(C), W(C), Commit

where

  • S(O) is a shared lock action on an object O
  • X(O) is an exclusive lock action on an object O
  • R(O) is a read action on an object O
  • W(O) is a write action on an object O

Strict 2PL prevents transactions reading uncommitted data, overwriting uncommitted data, and unrepeatable reads. Thus, it prevents cascading rollbacks, since eXclusive locks (for write privileges) must be held until a transaction commits.


Strict 2PL does not guarantee a deadlock-free schedule

Avoiding deadlocks can be important in real time systems, and may additionally be difficult to enforce in distributed data bases, or fault tolerant systems with multiple redundancy.

A deadlocked schedule allowed under Strict 2PL:

<math>G = \begin{bmatrix}

T1 & T2\\
X(A) & \\ 

 & X(B) &  \\

X(B) & \\ 

& X(A) \end{bmatrix}</math>

Text:
T1: X(A) T2:X(B) T1:X(B) T2: X(A)

T1 is waiting for T2’s lock on B to be released, while T2 is waiting for T1’s lock on A to be released. These transactions cannot proceed and both are deadlocked.

There is no general solution to the problem of deadlocks in computing systems, so they must be anticipated and dealt with accordingly. Nonetheless, several solutions such as the Banker’s algorithm or the imposition of a partial ordering on lock acquisition exist for avoiding deadlocks under certain conditions.

Even more strict than strict two-phase locking is rigorous two-phase locking, in which transactions can be serialized by the order in which they commit. Under rigorous 2PL, all locks (shared and exclusive) must be held until a transaction commits. Most database systems use strict 2PL.

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Tags: Uncategorized by admin
No Comments »

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Tags: Uncategorized by admin
No Comments »

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Locking

Locking can refer to:

  • Securing a physical object with a lock
  • Traversing a canal lock
  • an act of concurrency management in software
  • Locking, North Somerset, a village in the United Kingdom
  • Locking (dance), a style of funk dance invented in the early 1970s by Don Campbell
  • Fixing a mechanical object in place.
  • Joint locking in martial arts.


See also

  • Lock

Tags: Uncategorized by admin
No Comments »

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Tags: Uncategorized by admin
No Comments »

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Tags: Uncategorized by admin
No Comments »

Multiple granularity locking

In computer science, multiple granularity locking (MGL), sometimes called the John Rayner locking method, is a locking method used in database management systems (DBMS) and relational databases.

In MGL, locks are set on objects that contain other objects. MGL exploits the hierarchical nature of the contains relationship. For example, a database may have files, which contain pages, which further contain records. This can be thought of as a tree of objects, where each node contains its children. A lock locks a node and its descendants.

Multiple granularity locking is usually used with Non-strict two-phase locking to guarantee serializability. MGL uses lock escalation to determine granularity lock on a node and its ancestors.


Lock Modes

In addition to shared (S) locks and exclusive (X) locks from other locking schemes, like Strict two-phase locking, MGL also uses intention shared and intention exclusive locks. IS locks conflict with X locks, while IX locks conflict with S and X locks. The null lock (NL) is compatible with everything.

To lock a node in S (or X), MGL has the transaction locks all of its ancestors with IS (or IX), so if a transaction locks a node in S (or X), no other transaction can access its ancestors in X (or S and X).

MGL locking modes are compatible with each other as defined in the following matrix.

Mode NL IS IX S SIX EX
NL
IS
IX
S
SIX
EX

Tags: Uncategorized by admin
No Comments »

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Tags: Uncategorized by admin
No Comments »

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Tags: Uncategorized by admin
No Comments »

Index locking

Index locking is a procedure in which running one task on a database table blocks all access by other tasks to the entire table. With index locking it may be necessary to lock the index build for a column, not just the data items themselves. Index locking prevents conflicts between functions by ensuring that a table is not modified while a function is attempting to use it.

The circumstances where it is necessary to index lock include:

  • Adding a new level to the root page
  • Shrinking the root page
  • Splitting or shrinking the immediate child of the root page, causing an update on the root page

Circumstances where it is not necessary to Index lock include where:

  • Small tables with index levels no higher than 3 are being used.
  • Possible modifications to the root page of an index are envisioned.

Tags: Uncategorized by admin
No Comments »

Two phase locking

In Databases and Transaction processing, Two phase locking, (2PL) is a concurrency control locking protocol, mechanism, that guarantees Serializability. It is also the name of a class (set) of transaction schedules. Using locks that block processes, 2PL is subject to deadlocks that result from the mutual blocking of two transactions or more.


Two phase locking

According to the Two phase locking protocol, locks are handled by a transaction in two distinct, consecutive phases during the transaction’s execution:

Phase 1: Locks are acquired and no locks are released.

Phase 2: Locks are released and no locks are acquired.

The serializability property is guaranteed for a schedule with transactions that obey the protocol. The 2PL schedule class is defined as the class of all the schedules comprising transactions with data access orders that could be generated by the 2PL protocol.


Strict two phase locking

The Strict two phase locking (S2PL) class of schedules is the intersection of the 2PL class with the class of schedules possessing the Strictness property.

To comply with the S2PL protocol a transaction needs to comply with 2PL, and release its write (exclusive) locks only after it has ended, i.e., being either committed or aborted.

S2PL is a special case of 2PL, i.e., the S2PL class is a proper subclass of 2PL.


Strong strict two phase locking

To comply with the Strong strict two phase locking (SS2PL) protocol a transaction needs to comply with 2PL, and release both its write (exclusive) and read (shared) locks only after it has ended, i.e., being either committed or aborted.
A transaction obeying SS2PL can be viewed as having Phase 1 that lasts its entire execution duration, and no Phase 2 (or degenerate Phase 2). Thus, only one phase is actually left, and “two-phase” in the name seems to be still utilized due to the historical development of the concept from 2PL. The SS2PL property of a schedule is also called Rigorousness, and an SS2PL schedule is also called a Rigorous schedule.

SS2PL is a special case of S2PL, i.e., the SS2PL class of schedules is a proper subclass of S2PL (every SS2PL schedule is also an S2PL schedule, but S2PL schedules exist that are not SS2PL).

SS2PL is the concurrency control protocol of choice for most database systems since it provides besides serializability also Strictness, which is instrumental for efficient database recovery, and also Commitment ordering (CO) for participating in environments where a CO based Global serializability solution is employed.


See also

  • Serializability
  • Lock (computer science)

Tags: Uncategorized by admin
No Comments »

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.

Tags: Uncategorized by admin
No Comments »

Conservative two-phase locking

In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.

Conservative 2PL prevents deadlocks.

The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.

In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.

In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.

Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.