Deadlocks का कारण क्या होता है और आप उन्हें कैसे रोकते हैं?

Question

Accepted Answer

एक **deadlock** तब होता है जब दो (या अधिक) transactions प्रत्येक एक lock रखते हैं जिसकी दूसरे को आवश्यकता है, इसलिए कोई आगे नहीं बढ़ सकता — वे एक-दूसरे की हमेशा के लिए प्रतीक्षा करते हुए फंस जाते हैं। Databases deadlocks का पता लगाते हैं और **एक transaction को abort करके** ("victim") उन्हें हल करते हैं, जिसे retry करना होता है। कारणों और रोकथाम को समझना concurrent applications के लिए महत्वपूर्ण है।

## एक deadlock कैसे होता है

```text
Transaction A: locks row 1, then wants row 2
Transaction B: locks row 2, then wants row 1
→ A waits for B (to release row 2), B waits for A (to release row 1) → DEADLOCK
  Neither can proceed; they're waiting on each other in a cycle.
```

```sql
-- Transaction A                    -- Transaction B (concurrent)
BEGIN;                              BEGIN;
UPDATE accounts SET .. WHERE id=1;  UPDATE accounts SET .. WHERE id=2;  -- each locks a row
UPDATE accounts SET .. WHERE id=2;  UPDATE accounts SET .. WHERE id=1;  -- each wants the OTHER's
-- → DEADLOCK: the database aborts one transaction
```

## Databases deadlocks को कैसे handle करते हैं

```text
Databases DETECT deadlocks (find the cycle of waiting transactions) and resolve them
by ABORTING one transaction (the victim) with a deadlock error → it must RETRY.
→ Your application must handle the deadlock error and retry the transaction.
```

## रोकथाम रणनीतियाँ

```text
✓ CONSISTENT LOCK ORDERING — always acquire locks in the SAME order (e.g. always
  lock the lower account id first). This breaks the cycle → the #1 prevention technique.
✓ Keep transactions SHORT — hold locks for less time (less chance to overlap)
✓ Access tables/rows in a consistent order across all transactions
✓ Use lower isolation levels where appropriate (less locking)
✓ Avoid user interaction / long operations inside a transaction (holds locks too long)
✓ Handle deadlock errors with RETRY logic (deadlocks can't be fully eliminated)
```

**#1 रोकथाम** है **consistent lock ordering**: यदि सभी transactions locks को एक ही क्रम में acquire करते हैं (जैसे हमेशा lower id पहले), circular wait बन ही नहीं सकता।

## Retry pattern

```text
Since deadlocks can still happen, applications should catch the deadlock error and
RETRY the transaction (often a few times with a small delay). This is standard
resilience for concurrent database code.
```

## यह क्यों महत्वपूर्ण है

Deadlocks databases में एक महत्वपूर्ण concurrency समस्या हैं — वे overlapping data को modify करने वाले concurrent transactions के साथ किसी भी application में होते हैं, और इन्हें समझना robust concurrent systems बनाने के लिए मूल्यवान senior-level ज्ञान है।

**कारण** को समझना — दो transactions प्रत्येक एक lock रखते हैं जिसकी दूसरे को आवश्यकता है, एक circular wait बनाते हुए जहाँ कोई आगे नहीं बढ़ सकता — आधार है।

यह जानना कि databases deadlocks को कैसे **handle** करते हैं (cycle का पता लगाना और एक transaction को victim के रूप में abort करना, जिसे retry करना होता है) महत्वपूर्ण है क्योंकि इसका अर्थ है कि आपके **application को retry logic के साथ deadlock errors को handle करना होगा** — deadlocks को पूरी तरह समाप्त नहीं किया जा सकता, इसलिए resilient concurrent code deadlock error को catch करता है और retry करता है (एक standard, महत्वपूर्ण pattern)।

**रोकथाम रणनीतियाँ** मुख्य व्यावहारिक ज्ञान हैं, विशेष रूप से #1 technique: **consistent lock ordering** (हमेशा सभी transactions में locks को एक ही क्रम में acquire करना, जो circular-wait condition को तोड़ता है जो deadlocks का कारण बनती है) — साथ ही transactions को short रखना (locks को संक्षेप में रखना), resources को consistent order में access करना, और transactions के भीतर long operations से बचना।

चूंकि deadlocks concurrent database applications में real problems (failed transactions, errors, degraded performance) का कारण बनते हैं, और चूंकि उनके कारण (circular lock waits), रोकथाम (विशेष रूप से consistent lock ordering और short transactions), और retry logic की आवश्यकता को समझना ही आपको robust concurrent systems बनाने देता है, deadlocks को समझना significant concurrent database access वाले किसी भी application के लिए मूल्यवान senior-level ज्ञान है — एक बार-बार प्रासंगिक operational चिंता और database concurrency व resilience की समझ दर्शाने वाला एक common advanced interview topic।