In context of deadlock prevention in DBMS, wait-die and wound-wait schemes are ...... techniques.

Question

Accepted Answer

The correct option is (4):
The Wait-Die and Wound-Wait schemes are crucial deadlock prevention techniques in a Database Management System (DBMS) that use timestamps to enforce a strict ordering on transactions, thereby preventing the circular wait condition. The key difference lies in whether a resource is forcibly taken from its current holder, which defines preemption. The **Wait-Die** scheme is **non-preemptive**. When an older transaction $T\_i$ requests a resource held by a younger transaction $T\_j$, $T\_i$ waits. However, if a younger transaction $T\_i$ requests a resource held by an older transaction $T\_j$, $T\_i$ is immediately rolled back (dies). The resource is never forcibly preempted from the holder ($T\_j$), making it non-preemptive. Conversely, the **Wound-Wait** scheme is **preemptive**. If an older transaction $T\_i$ requests a resource held by a younger transaction $T\_j$, $T\_i$ "wounds" or forces $T\_j$ to roll back and release the resource, which is a preemption. Only if $T\_i$ is younger than $T\_j$ is $T\_i$ made to wait. Therefore, Wait-Die is non-preemptive and Wound-Wait is preemptive, matching the second part of option 4.

The incorrect option is (1):
This option states that both schemes are preemptive, which is incorrect because the Wait-Die scheme is fundamentally non-preemptive. In a preemptive scheme, the system can forcibly take a resource away from a transaction that currently holds it and allocate it to another, often higher-priority, transaction. The Wait-Die scheme ensures that the transaction holding the resource is only ever released voluntarily or when it commits, as the waiting/younger transaction is the one that is rolled back if conflict occurs with an older resource holder. Thus, equating Wait-Die with preemption is a conceptual error.

The incorrect option is (2):
This option states that both schemes are non-preemptive, which is also incorrect, specifically because the Wound-Wait scheme involves preemption. A non-preemptive scheme guarantees that a resource, once allocated to a transaction, cannot be taken away until the transaction voluntarily releases it. The Wound-Wait scheme directly violates this principle when an older transaction forces a younger transaction to abort and relinquish its resource, which is the definition of preemption. Therefore, characterizing Wound-Wait as non-preemptive is inaccurate.

The incorrect option is (3):
This option states that the schemes are preemptive and non-preemptive respectively, meaning Wait-Die is preemptive and Wound-Wait is non-preemptive. This incorrectly reverses the nature of the two schemes. It would imply that Wait-Die allows an older transaction to take a resource from a younger one, and that Wound-Wait makes the younger transaction always wait without forcing a rollback, which contradicts the core logic of timestamp-based deadlock prevention. The correct relationship is the opposite: Wait-Die is non-preemptive, and Wound-Wait is preemptive.