Como funcionam as listas Redis e como são usadas para filas?

Question

Accepted Answer

As **listas** Redis são coleções ordenadas de strings (implementadas como listas encadeadas) com push/pop rápidos em ambas as extremidades. Elas são comumente usadas para implementar **filas** e **pilhas** — uma forma simples e popular de usar Redis para processamento de jobs e dados ordenados.

## Operações de lista

```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 em qualquer extremidade são rápidos (O(1)). `LRANGE` lê intervalos. Essas operações tornam as listas ideais para dados ordenados, semelhantes a filas.

## Implementando uma fila (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
```

Uma **fila** (primeiro-a-entrar-primeiro-a-sair): produtores `LPUSH` (adicionam a uma extremidade), consumidores `RPOP` (removem da outra) — o padrão clássico de fila de jobs Redis.

## Pops bloqueantes (consumidores eficientes)

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

**Pops bloqueantes** (`BLPOP`/`BRPOP`) permitem que um consumidor aguarde eficientemente novos itens em vez de fazer polling constante — importante para workers de fila responsivos e eficientes.

## Pilha e outros padrões

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

## Por que isso importa

As listas Redis e seu uso para filas são conhecimento Redis comumente aplicado e prático, portanto compreendê-los é valioso para muitos casos de uso reais.

Listas (coleções ordenadas de strings com **push/pop O(1) rápido em ambas as extremidades**) são versáteis, mas sua aplicação mais importante é implementar **filas** — usando `LPUSH`/`RPOP` (ou o inverso) para construir uma **fila de jobs FIFO** onde produtores adicionam trabalho e consumidores o processam em ordem, um padrão simples e extremamente comum para processamento de jobs em background, distribuição de tarefas e desacoplamento de produtores e consumidores.

Isso torna Redis uma fila de mensagens/jobs leve e popular sem precisar de um sistema de fila dedicado para necessidades mais simples.

Compreender **pops bloqueantes** (`BLPOP`/`BRPOP`) é particularmente importante para workers de fila eficientes — eles permitem que consumidores aguardem novos itens em vez de fazer polling desperdiçador em loop, tornando workers responsivos e eficientes (uma técnica prática chave para implementações reais de filas).

Conhecer outros padrões — **pilhas** (LIFO, pushando/popando a mesma extremidade) e **listas limitadas** (usando `LTRIM` para manter apenas os N itens mais recentes, ideal para feeds de atividade e listas de itens recentes) — estende a utilidade das listas.

Como filas de jobs e dados ordenados são necessidades comuns, e como as listas Redis fornecem uma forma simples, rápida e popular de implementar filas (com pops bloqueantes para consumidores eficientes), pilhas e feeds de itens recentes, compreender as listas Redis e o padrão de fila é conhecimento valioso e frequentemente aplicado para usar Redis em aplicações reais, um dos usos práticos mais comuns de Redis além de caching e um bloco de construção para processamento em background e arquiteturas desacopladas.