Redis ఉపయోగించి విభజిత తాళ్ళు (distributed locks) ఎలా పని చేస్తాయి?

Question

Accepted Answer

ఒక **విభజిత తాళ్ళు** (distributed lock) బహుళ ప్రక్రియలు/సర్వర్‌ల వెంట భాగస్వామ్య వనరుకు యాక్సెస్‌ను సమన్వయం చేస్తాయి కాబట్టి ఒకసారికి ఒకటి మాత్రమే తాళ్లను కలిగి ఉంటాయి. Redis సాధారణంగా ఈ కోసం పరమాణు set-if-not-exists తో TTL ద్వారా ఉపయోగించబడుతుంది — అయితే దీన్ని సరిగ్గా చేయటానికి జాగరూకత (మరియు పరిమితులను అర్థం చేసుకోవడం) అవసరం.

## ప్రాథమిక Redis తాళ్ళు (SET NX with TTL)

```js
// acquire: SET the lock key only if it doesn't exist, with a TTL (auto-release safety)
const token = randomUUID();   // a unique token identifying THIS lock holder
const acquired = await redis.set("lock:resource", token, "NX", "EX", 30);
// NX = set only if not exists (atomic); EX 30 = auto-expire in 30s (avoid deadlock)

if (acquired) {
  try {
    // ... do the work that needs exclusive access ...
  } finally {
    // release ONLY if WE still hold it (check the token) — use a Lua script for atomicity
    await releaseLock("lock:resource", token);
  }
}
```

తాళ్ళు **`SET key value NX EX`** ఉపయోగిస్తాయి: కీని పరమాణువుగా సెట్ చేయండి, ఐచ్ఛికంగా ఉండిస్తూ (కాబట్టి ఒక క్లায়েంట్ మాత్రమే విజయవంతమవుతుంది) **TTL** తో (కాబట్టి విధానం క్రాష్ చేస్తే తాళ్ళు స్వయంచాలకంగా విడుదల అవుతాయి, ముందుకు సంకेతాన్ని నివారిస్తుంది).

## రెండు క్లిష్టమైన సరిసంబంధం వివరాలు

```text
1. ALWAYS set a TTL → if the lock holder crashes, the lock auto-expires
   (otherwise the resource is locked forever — a deadlock)
2. Use a UNIQUE TOKEN + release only if it matches → so you don't release
   SOMEONE ELSE'S lock (e.g. if your TTL expired and another client acquired it).
   Release must be ATOMIC (check-token-then-delete via a Lua script).
```

```lua
-- safe release: delete only if the value matches our token (atomic via Lua)
if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end
```

## పరిమితులు మరియు Redlock

```text
⚠️ A single-Redis lock isn't perfectly safe: if the TTL expires mid-work, or with
   failover (the lock not yet replicated), two clients could both hold it.
→ REDLOCK algorithm → acquire the lock across MULTIPLE independent Redis nodes
   (majority) for stronger guarantees (though even Redlock is debated).
→ For critical correctness, combine with fencing tokens or use a system designed for
   consensus (e.g. ZooKeeper/etcd). Know the trade-offs.
```

## ఇది ఎందుకు ముఖ్యమైనది

Redis ఉపయోగించి విభజిత తాళ్లను అర్థం చేసుకోవడం **విభజిత వ్యవస్థల్లో భాగస్వామ్య వనరులకు యాక్సెస్‌ను సమన్వయం చేయటానికి** విలువైనది, కాబట్టి ఇది ఉపయోగకరమైన జ్ఞానం — మరియు సరిసంబంధం యొక్క లోపాలను అర్థం చేసుకోవడం విশేషంగా ముఖ్యమైనది.

विभజిత తాళ్లు నిజమైన అవసరాన్ని పరిష్కరిస్తాయి: బహు-సర్వర్ సిస్టమ్‌లలో ఒక ప్రక్రియ/సర్వర్ మాత్రమే ఒక క్లిష్టమైన చర్యను నిర్వహిస్తుందని నిశ్చితం చేయడం (నకిలీ ప్రక్రియ, భాగస్వామ్య వనరులపై రేస్ పరిస్థితులు, లేదా విరుద్ధమైన కార్యకలాపాలను నివారించడం), మరియు Redis దీని కోసం సాధారణ సాధనం.

**ప్రాథమిక యంత్రం** అర్థం చేసుకోవడం — `SET key value NX EX` (పరమాణువు set-if-not-exists TTL తో) కాబట్టి ఒక క్లయింట్ మాత్రమే తాళ్లను పొందుతుంది మరియు ఇది క్రాష్‌లో స్వయంచాలకంగా విడుదల అవుతుంది — ఇది ఆధారమైన పద్ధతి.

కీలకంగా, **రెండు సరిసంబంధం వివరాల** అర్థం చేసుకోవడం అవసరం: **ఎల్లప్పుడు TTL ఉపయోగించడం** (కాబట్టి క్రాష్ చేయిన విధానం యొక్క తాళ్ళు స్వయంచాలకంగా ముగియాయి, శాశ్వత డెడ్‌లాక్‌ను నివారిస్తుంది) మరియు **ప్రత్యేక టోకెన్‌ను సరిపోల్చిన విడుదలతో ఉపయోగించడం** (కాబట్టి మీ TTL ఆగిపోయితే మరొక క్లయింట్ యొక్క తాళ్లను నిర్ఘంటకంగా విడుదల చేయవద్దు — Lua స్క్రిప్ట్ ద్వారా పరమాణువు చెక్-ఆ-డిలీట్ తో).

ఈ వివరాలు ప్రీ-తయారీ అమలుల సూక్ష్మమైన, ప్రమాదకరమైన బగ్‌లను కలిగి ఉన్న చోటు.

సమానంగా ముఖ్యమైన **పరిమితులను** అర్థం చేసుకోవడం: ఒక-Redis తాళ్ళు సంపూర్ణంగా సురక్షితం కాదు (TTL ఎక్సపిరీ మిడ్-వర్క్ లేదా ఫెయిల్‌ఓవర్ రెండు క్లయింట్‌లను కలిగి ఉండేలా చేస్తుంది), **Redlock** అల్గోరిథం (బహుళ Redis నోడ్‌ల వెంట సేకరించడం) బలమైన గ్యారంటీల కోసం — మరియు నిర్ణయాత్మక సరిసంబంధం కోసం, కవచం టోకెన్‌లు లేదా సమాఖ్య వ్యవస్థలు (ZooKeeper/etcd) అవసరం కావచ్చని తెలుసుకోవడం.

ఈ వర్తక-ఆఫ్‌లు మరియు పరిమితుల యొక్క సూక్ష్మ అర్థం ప్రాప్త అర్థాన్ని ప్రతిబింబిస్తుంది.

భాగస్వామ్య-వనరు యాక్సెస్‌ను విభజిత వ్యవస్థల్లో సమన్వయం చేయటం నిజమైన అవసరం కాబట్టి, మరియు Redis విభజిత తాళ్లు సాధారణ కానీ జాగరూకతపూర్వక సరిసంబంధ అమలు (TTL, ప్రత్యేక టోకెన్, పరమాణువు విడుదల) మరియు వాటి పరిమితుల (Redlock, ఫెయిల్‌ఓవర్ ఝుమ్ముకలు) యొక్క సూక్ష్మత అవసరం కాబట్టి, Redis ఉపయోగించి విభజిత తాళ్లను అర్థం చేసుకోవడం — యంత్రం, సరిసంబంధం వివరాలు, మరియు పరిమితులు — విభజిత సమన్వయానికి విలువైన, ఆచరణాత్మకంగా సంబంధితమైన జ్ఞానం, పరిమితుల మరియు వర్తక-ఆఫ్‌ల యొక్క అర్థం ప్రాథమిక పద్ధతి విషయం.