Redis lists कैसे काम करती हैं और इन्हें queues के लिए कैसे उपयोग किया जाता है?

Question

Accepted Answer

Redis **lists** strings के ordered collections हैं (linked lists के रूप में लागू) जिनमें दोनों सिरों पर तेज़ push/pop होता है। इनका उपयोग सामान्यतः **queues** और **stacks** लागू करने के लिए होता है — job processing और ordered डेटा के लिए Redis का उपयोग करने का एक सरल, लोकप्रिय तरीका।

## List operations

```bash
LPUSH mylist "a"        # push to the LEFT (head)
RPUSH mylist "b"        # push to the RIGHT (tail)
LPOP mylist             # pop from the LEFT
RPOP mylist             # pop from the RIGHT
LRANGE mylist 0 -1      # get a range (0 to -1 = all elements)
LLEN mylist             # length
LINDEX mylist 0         # element at an index
```

किसी भी सिरे पर push/pop तेज़ होते हैं (O(1))। `LRANGE` ranges पढ़ता है। ये operations lists को ordered, queue-जैसे डेटा के लिए आदर्श बनाते हैं।

## एक queue लागू करना (FIFO)

```bash
# Producer adds jobs; consumer processes them in order (FIFO)
LPUSH job_queue "job1"    # producer pushes to the left
LPUSH job_queue "job2"
RPOP job_queue            # consumer pops from the right => "job1" (first in, first out)
# push left + pop right = FIFO queue
```

एक **queue** (first-in-first-out): producers `LPUSH` करते हैं (एक सिरे पर जोड़ना), consumers `RPOP` करते हैं (दूसरे सिरे से हटाना) — क्लासिक Redis job queue pattern।

## Blocking pops (कुशल consumers)

```bash
# BRPOP blocks (waits) until an element is available — no busy polling
BRPOP job_queue 5     # wait up to 5 seconds for a job (0 = wait forever)
# → the consumer efficiently waits for work instead of repeatedly polling
```

**Blocking pops** (`BLPOP`/`BRPOP`) एक consumer को लगातार polling करने के बजाय नए items के लिए कुशलता से प्रतीक्षा करने देते हैं — responsive, कुशल queue workers के लिए महत्वपूर्ण।

## Stack और अन्य patterns

```bash
# STACK (LIFO): push and pop from the SAME end
LPUSH stack "a"; LPOP stack    # last in, first out

# capped list (e.g. keep the last 100 items — recent activity feed)
LPUSH recent "event"; LTRIM recent 0 99   # keep only indices 0-99
```

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

Redis lists और queues के लिए उनका उपयोग सामान्यतः लागू होने वाला, व्यावहारिक Redis ज्ञान है, इसलिए इन्हें समझना कई वास्तविक use cases के लिए मूल्यवान है।

Lists (**दोनों सिरों पर तेज़ O(1) push/pop** वाले ordered string collections) बहुमुखी हैं, लेकिन इनका सबसे महत्वपूर्ण अनुप्रयोग **queues** लागू करना है — `LPUSH`/`RPOP` (या इसके विपरीत) का उपयोग करके एक **FIFO job queue** बनाना जहाँ producers काम जोड़ते हैं और consumers इसे क्रम में process करते हैं, background job processing, task distribution, और producers को consumers से decoupling करने के लिए एक सरल और अत्यंत सामान्य pattern।

यह Redis को सरल ज़रूरतों के लिए बिना किसी समर्पित queue system के एक लोकप्रिय lightweight message/job queue बनाता है।

**blocking pops** (`BLPOP`/`BRPOP`) को समझना कुशल queue workers के लिए विशेष रूप से महत्वपूर्ण है — ये consumers को एक loop में बेकार polling करने के बजाय नए items के लिए प्रतीक्षा करने देते हैं, workers को responsive और कुशल बनाते हैं (वास्तविक queue implementations के लिए एक मुख्य व्यावहारिक तकनीक)।

अन्य patterns को जानना — **stacks** (LIFO, एक ही सिरे पर push/pop) और **capped lists** (केवल हाल के N items रखने के लिए `LTRIM` का उपयोग, activity feeds और recent-items lists के लिए आदर्श) — lists की उपयोगिता को बढ़ाता है।

चूँकि job queues और ordered डेटा सामान्य ज़रूरतें हैं, और चूँकि Redis lists queues (कुशल consumers के लिए blocking pops के साथ), stacks, और recent-items feeds लागू करने का एक सरल, तेज़, लोकप्रिय तरीका प्रदान करती हैं, इसलिए Redis lists और queue pattern को समझना वास्तविक applications में Redis का उपयोग करने के लिए मूल्यवान, बार-बार लागू होने वाला ज्ञान है, caching से परे Redis के सबसे सामान्य व्यावहारिक उपयोगों में से एक और background processing तथा decoupled architectures के लिए एक building block।