Wound-Wait Scheme: Deadlock Prevention in DBMS Explained

The wound-wait scheme is a deadlock prevention method in database management systems where older transactions can 'wound' (force rollback) younger transactions to avoid waiting. If a younger transaction requests a resource held by an older one, it waits; if an older transaction requests a resource held by a younger one, it forces the younger to roll back.

How It Works

The wound-wait scheme uses the age of transactions to decide who waits and who rolls back. Imagine two people wanting to use the same tool: if the older person wants it, the younger one must give it up and try again later. But if the younger person wants the tool while the older one is using it, the younger person waits patiently.

This way, the system avoids deadlocks by preventing circular waiting. Older transactions 'wound' younger ones by forcing them to restart, while younger transactions wait for older ones to finish. This keeps the system moving smoothly without getting stuck.

Example

This example simulates two transactions competing for a resource using the wound-wait scheme logic.

python

class Transaction:
    def __init__(self, id, timestamp):
        self.id = id
        self.timestamp = timestamp  # Lower means older
        self.active = True

class Resource:
    def __init__(self):
        self.locked_by = None

    def request(self, transaction):
        if self.locked_by is None:
            self.locked_by = transaction
            print(f"Transaction {transaction.id} acquired the resource.")
        else:
            holder = self.locked_by
            if transaction.timestamp < holder.timestamp:
                # Older transaction wounds younger
                print(f"Transaction {transaction.id} (older) wounds Transaction {holder.id} (younger).")
                holder.active = False
                self.locked_by = transaction
                print(f"Transaction {holder.id} rolled back.")
                print(f"Transaction {transaction.id} acquired the resource.")
            else:
                # Younger transaction waits
                print(f"Transaction {transaction.id} (younger) waits for Transaction {holder.id} (older).")

# Create transactions
T1 = Transaction('T1', 1)  # Older
T2 = Transaction('T2', 2)  # Younger

resource = Resource()

# T2 acquires resource first
resource.request(T2)

# T1 requests resource later
resource.request(T1)

Output

Transaction T2 acquired the resource.
Transaction T1 (older) wounds Transaction T2 (younger).
Transaction T2 rolled back.
Transaction T1 acquired the resource.

When to Use

The wound-wait scheme is useful in database systems where preventing deadlocks is critical for smooth operation. It works best when transactions have clear timestamps or ages to compare.

Use it in systems where older transactions should have priority to avoid long waits and where rolling back younger transactions is acceptable. This scheme helps maintain system responsiveness and fairness by reducing deadlock chances.

Real-world use cases include banking systems, reservation systems, and any multi-user database where concurrent access to shared data is common.

Key Points

• Wound-wait uses transaction age to prevent deadlocks.
• Older transactions can force younger ones to roll back.
• Younger transactions wait if the resource is held by an older one.
• This scheme avoids circular waiting and deadlocks.
• It prioritizes older transactions to keep the system efficient.

Key Takeaways

Wound-wait prevents deadlocks by letting older transactions roll back younger ones.

Younger transactions wait if the resource is held by an older transaction.

This scheme avoids circular waits and keeps the system running smoothly.

It is best used when transaction timestamps are available and rollback is acceptable.

Wound-wait prioritizes older transactions to improve system fairness and efficiency.