Bagaimana Redis lists bekerja dan bagaimana penggunaannya untuk antrian?

Question

Accepted Answer

Redis **lists** adalah koleksi string terurut (diimplementasikan sebagai linked lists) dengan operasi push/pop cepat di kedua ujung. Mereka umum digunakan untuk mengimplementasikan **queues** dan **stacks** — cara sederhana dan populer untuk menggunakan Redis dalam pemrosesan job dan data terurut.

## Operasi list

```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 di kedua ujung cepat (O(1)). `LRANGE` membaca rentang. Operasi-operasi ini membuat lists ideal untuk data terurut, seperti antrian.

## Mengimplementasikan antrian (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
```

Sebuah **antrian** (first-in-first-out): producer melakukan `LPUSH` (menambah di satu ujung), consumer melakukan `RPOP` (menghapus dari ujung lain) — pola klasik Redis job queue.

## Blocking pops (consumer efisien)

```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`) memungkinkan consumer menunggu secara efisien untuk item baru daripada terus melakukan polling — penting untuk queue workers yang responsif dan efisien.

## Stack dan pola lainnya

```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
```

## Mengapa ini penting

Redis lists dan penggunaannya untuk antrian adalah pengetahuan Redis yang praktis dan umum diterapkan, jadi memahaminya sangat berharga untuk banyak use case nyata.

Lists (koleksi string terurut dengan **push/pop O(1) yang cepat di kedua ujung**) sangat serbaguna, tetapi aplikasi paling pentingnya adalah mengimplementasikan **antrian** — menggunakan `LPUSH`/`RPOP` (atau sebaliknya) untuk membangun **antrian job FIFO** di mana producer menambahkan pekerjaan dan consumer memprosesnya secara berurutan, pola sederhana dan sangat umum untuk pemrosesan background job, distribusi task, dan decoupling producer dari consumer.

Ini membuat Redis menjadi message/job queue yang populer dan ringan tanpa perlu sistem antrian khusus untuk kebutuhan yang lebih sederhana.

Memahami **blocking pops** (`BLPOP`/`BRPOP`) sangat penting untuk queue workers yang efisien — mereka memungkinkan consumer menunggu item baru daripada melakukan polling yang boros dalam loop, membuat workers responsif dan efisien (teknik praktis kunci untuk implementasi queue nyata).

Mengetahui pola lainnya — **stacks** (LIFO, push/pop pada ujung yang sama) dan **capped lists** (menggunakan `LTRIM` untuk menjaga hanya N item terbaru, ideal untuk activity feeds dan recent-items lists) — memperluas kegunaan lists.

Karena antrian job dan data terurut adalah kebutuhan umum, dan karena Redis lists menyediakan cara sederhana, cepat, dan populer untuk mengimplementasikan antrian (dengan blocking pops untuk consumer efisien), stacks, dan recent-items feeds, memahami Redis lists dan pola antrian adalah pengetahuan yang berharga dan sering diterapkan untuk menggunakan Redis dalam aplikasi nyata, salah satu use case praktis paling umum dari Redis di luar caching dan building block untuk background processing serta decoupled architectures.