Concurrency questions look like vocabulary tests until you write the schedule out. The same two transactions give you a dirty read or a lost update depending only on where the commit sits, and one lock entry often settles which label is correct. The ten previous-year questions below are worked that way: the operation order first, the label second. Commit to an option before you read the explanation.
Uncontrolled concurrent updates: identify all consequences
Q1
Asked in UGC NET, December 2019.
Two concurrent executing transactions T1 and T2 are allowed to update same stock item say ′A′ in an uncontrolled manner. In such scenario, following problems may occur:
(a) Dirty read problem
(b) Lost update problem
(c) Transaction failure
(d) Inconsistent database state
Which of the following option is correct if database system has no concurrency module and allows concurrent execution of above two transactions?
(a)
(a), (b) and (c) only(b)
(c) and (d) only(c)
(a) and (b) only(d)
(a), (b) and (d) only
Answer: (d) (a), (b) and (d) only. Full solution
Start with A = 100. For a dirty read, T1 writes 120 without committing, T2 reads 120, then T1 aborts, so T2 used a value that never became durable. For a lost update, both transactions read 100; T1 writes 110; T2 writes 125 from its stale copy. The final 125 erases T1's +10. These interleavings can also create an inconsistent state, but uncontrolled access does not itself force a transaction to fail. Hence (a), (b), and (d) only.
Read sets, write sets, and the isolation ceiling
Q2
Asked in UGC NET, June 2015.
Let P_i and P_j be two processes, R be the set of variables read from memory, and W be the set of variables written to memory. For the concurrent execution of two processes P_i and P_j, which of the conditions are not true?
(a)
R(P_i) ∩ W(P_j) = Φ(b)
W(P_i) ∩ R(P_j) = Φ(c)
R(P_i) ∩ R(P_j) = Φ(d)
W(P_i) ∩ W(P_j) = Φ
Answer: (c) R(P_i) ∩ R(P_j) = Φ. Full solution
Take R(P_i) = {x, y}, W(P_i) = {z}, R(P_j) = {x}, and W(P_j) = {w}. Here R(P_i) ∩ R(P_j) = {x}, which is safe because both processes only read x. The read-write, write-read, and write-write intersections are all empty. Those three kinds of overlap could create interference, but a shared read cannot. Therefore the two read sets need not be disjoint. Choice (c) is the condition that is not required for this concurrent execution.
Q3
Asked in ISRO, 2013.
Which of the following is the highest isolation level in transaction management?
(a)
Serializable(b)
Repeated Read(c)
Committed Read(d)
Uncommitted Read
Answer: (a) Serializable. Full solution
Using the option wording, the order from weakest to strongest is Uncommitted Read, Committed Read, Repeated Read, then Serializable. Serializable requires a concurrent result to match a complete serial order, such as T1 then T2 or T2 then T1. It controls the schedule's overall effect, not just one repeated read, so its promise is stronger than the lower levels. Choice (a) is therefore highest. Review the framework in Transactions and Concurrency Control in DBMS.
Timestamp ordering and Strict Two-Phase Locking
Q4
Asked in DSSSB, 2021.
_____ is a unique identifier created by database management system to identify the relative starting time of a transaction.
(a)
Timestamp(b)
Spoofing(c)
Shadow paging(d)
Deadlock
Answer: (a) Timestamp. Full solution
Suppose TS(T1) = 12 and TS(T2) = 27. The smaller value identifies T1 as the earlier transaction, and timestamp ordering uses this relative age when deciding whether an operation may proceed. Only relative order matters here, not elapsed time. Shadow paging is a recovery technique, deadlock is a circular waiting condition, and spoofing is unrelated to transaction start order. The requested DBMS-created identifier is therefore a timestamp, making choice (a) correct.
Q5
Asked in RPSC, 2024.
Which of the following problem(s) can occur in the Strict Two-Phase Locking (Strict 2PL) protocol?
(a)
Chances of deadlock(b)
Cascading Rollback(c)
Neither 1 nor 2(d)
Both 1 & 2
Answer: (a) Chances of deadlock. Full solution
T1 acquires X(A), T2 acquires X(B), T1 requests X(B) and waits, then T2 requests X(A) and waits. This circular wait proves that Strict 2PL can deadlock. However, it retains an exclusive lock until commit or abort, so another transaction cannot read that uncommitted write and later need a cascading rollback. Strict 2PL gives conflict serializability and blocks dirty reads of exclusive writes, but neither property gives deadlock freedom. Only problem 1 can occur, so choice (a) is correct.
Deadlock prevention and multigranularity lock compatibility
Q6
Asked in HTET, 2022.
In context of deadlock prevention in DBMS, wait-die and wound-wait schemes are ........ techniques.
(a)
both preemptive(b)
both non-preemptive(c)
preemptive and non-preemptive respectively(d)
non-preemptive and preemptive respectively
Answer: (d) non-preemptive and preemptive respectively. Full solution
Let TS(T_old) = 5 and TS(T_young) = 20. In wait-die, an older requester may wait for a younger holder, while a younger requester aborts if the older transaction holds the lock. The holder is not forced out, so wait-die is non-preemptive. In wound-wait, an older requester forces a younger holder to roll back, so it is preemptive. The standard classification is choice (d). The trap is the order of the two names in the stem: wait-die is listed first, so the non-preemptive label has to come first as well, which rules out choice (c).
Q7
Asked in UGC NET, December 2025.
If a transaction ta holds a lock on some data item d in shared and intention-exclusive (SIX) mode, then which of the following is true for another transaction tb?
1. tb can lock d in shared (S) mode
2. tb can lock d in exclusive (X) mode
3. tb can lock d in intention-exclusive (IX) mode
4. tb can lock d in intention-shared (IS) mode
(a)
1(b)
2(c)
3(d)
4
Answer: (d) 4. Full solution
Check every mode against the SIX lock on the same object d. SIX combines shared access at d with an intention to take exclusive locks below it. Another transaction's S lock conflicts with that exclusive intention, X conflicts with both parts, and IX conflicts with the shared part. IS only announces an intention to take shared locks lower in the hierarchy, so it is compatible with SIX at d. Only statement 4 is true, and the option naming statement 4 is choice (d).
Temporary updates, read-write conflicts, and phantom rows
Q8
Asked in UGC NET, June 2012.
The problem that occurs when one transaction updates a database item and then the transaction fails for some reason is ________.
(a)
Temporary Select Problem(b)
Temporary Modify Problem(c)
Dirty Read Problem(d)
None
Answer: (d) None. Full solution
Set balance = 500. T1 writes 450 and then fails before commit. This is commonly called a temporary update, but that term is absent from the choices. A dirty read would additionally require T2 to read the uncommitted 450 before T1 aborts, and the stem gives no such read. Temporary Select Problem and Temporary Modify Problem are not the standard label. Among the listed choices, None is therefore the one that fits: the stem stops at the failure, before any second transaction has read the value.
Q9
Asked in DSSSB, 2018.
Which of the following concurrency anomalies is also known as a read-write conflict?
(a)
Dirty read(b)
Lost update problem(c)
Unrepeatable read(d)
Uncommitted dependency
Answer: (c) Unrepeatable read. Full solution
Let X = 100. T1 reads 100; T2 writes X = 120 and commits; T1 reads X again and sees 120. The two reads disagree because T2's intervening write creates a read-write conflict. That is an unrepeatable read, so choice (c) fits. By contrast, a write followed by another transaction reading the uncommitted value is a dirty read. Two transactions reading the same old value and then writing can produce a lost update. Here the defining order is read, committed write, reread.
Q10
Asked in MPPSC, 2025.
What is phantom read in the context of transaction isolation levels?
(a)
A transaction reads a set of rows that were inserted by another transaction after it started(b)
A transaction reads data that was committed by another transaction(c)
A transaction reads data that was changed by another transaction but not yet committed(d)
None of the above
Answer: (a) A transaction reads a set of rows that were inserted by another transaction after it started. Full solution
T1 runs SELECT id FROM accounts WHERE balance >= 1000 and gets {11, 18}. T2 inserts account 23 with balance 1400 and commits. T1 reruns the predicate and gets {11, 18, 23}. Row 23 is the phantom because the repeated query finds a new qualifying row, not merely a changed value in an existing row. An uncommitted changed value would instead indicate a dirty read. Choice (a) captures the changed result set caused by a later insertion.
The exam traps behind these ten answers
Do not memorise an anomaly label without rebuilding its operation order:
W1(A=120), R2(A=120)before T1 commits is a dirty read.R1(A=100), R2(A=100), W1(A=110), W2(A=125)is a lost update.R1(X=100), W2(X=120), R1(X=120)is an unrepeatable read.A repeated predicate changing from
{11, 18}to{11, 18, 23}is a phantom read.
For locks, remember that Strict 2PL prevents cascading rollback but can deadlock, a timestamp orders transactions but is not a lock, and SIX is compatible with IS at the same node among Q7's modes. Continue with DBMS Transaction MCQs for adjacent practice.
Short version and next practice step
Keep five rules ready: the same old value then two writes means lost update; uncommitted write then another transaction's read means dirty read; read, other write, then reread means unrepeatable read; a changed result set means phantom; strict locking can still deadlock.
Redo the questions without notes. Mark each anomaly WR, RW, or WW, draw the two-node Strict 2PL wait-for cycle, and revisit answers you cannot justify in two sentences.
Next, use GATE Guidance by Sanchit Sir for the DBMS sequence, GATE Test Series for timed practice, or compare options in the GATE CS Exam category.
