A Redis list and a sorted set solve different problems

Tue, 04 Jan 2028 00:00:00 +0000

A Redis list stores an ordered sequence that permits repeated values. A sorted set stores unique members ordered by numeric scores. The useful distinction is not that one is universally faster or cheaper: it is whether the application needs positional sequence operations, unique membership, score ranges, or a combination requiring a different data model.

Define what makes an entry distinct

With RPUSH, a list keeps values in append order, including duplicates. RPUSH followed by LPOP removes the oldest value; RPUSH followed by RPOP removes the newest. Other choices of ends change that order, so a list is not automatically FIFO regardless of producer commands. Removal order also does not guarantee completion order among parallel workers.

ZADD associates one score with each member. Adding an existing member again updates that score rather than creating another record. Its default return value counts new members, so zero can be a successful update. Repeated event payloads used directly as member names will collapse into one membership, which is wrong when each occurrence represents separate work.

Equal scores are allowed. Ties sort by member bytes, not arrival time or locale-aware text order; REV reverses the tie order as well. A leaderboard may accept that rule, while a timestamp index may need a distinct event identifier and an explicit tie policy. Scores are floating-point numbers, so choose units that preserve the required numeric precision.

Positions and scores select different things

Lists support more than end access. LINDEX retrieves a position and LRANGE returns an inclusive positional range. Reaching an interior position involves traversal; end access is cheap, but a large response still costs work proportional to its size. A short capped list with head or tail reads can be appropriate.

ZRANGE defaults to zero-based rank positions with an inclusive end. BYSCORE interprets the bounds as numeric scores instead; an opening parenthesis excludes a score boundary. The documented range cost is O(log N + M), with N members and M results. Large result sets and deep offset scans are not free just because the structure is indexed.

Rank-based pagination in either changing structure is not a snapshot. Insertions or score updates can shift later pages, producing repeats or omissions across separate requests. Choose the read contract before selecting a container. There is no general guarantee of similar memory usage: representation, cardinality, payload sizes, and configuration all affect the result. Measure representative data when capacity is the deciding factor.

When it breaks

A timestamp score is not a member expiration deadline. ZREMRANGEBYSCORE explicitly removes a numeric interval, while LTRIM explicitly retains a positional window. Neither cleanup happens because time passed or a read occurred. A separate append and cleanup are separate operations, so retention logic needs its own execution and concurrency policy.

A sorted set also is not a complete delayed-work scheduler. ZPOPMIN immediately removes the minimum member, even if its score encodes a future time. Reading due entries and later removing them in a second command can let multiple workers select the same job. Atomic claiming, processing acknowledgement, and recovery of abandoned work are additional requirements, not properties supplied by a timestamp score.

List pops likewise remove values before business processing finishes. A consumer failure after removal can lose the task unless the application uses a suitable processing protocol. Choose lists for sequence operations and sorted sets for score-indexed membership; do not infer delivery guarantees from either ordering scheme.

Check it quickly

Use a POSIX environment with a C compiler, make, curl, tar, and Python 3.10 or newer. This ran on macOS with Python 3.14.4, Redis 8.10.1, and redis-py 8.1.0. The commands compile Redis core with libc and install its client in a temporary virtual environment, without optional modules or system-wide installation.

redis_lab=$(mktemp -d)
curl --fail --location --output "$redis_lab/redis.tar.gz" https://download.redis.io/releases/redis-8.10.1.tar.gz
tar -xzf "$redis_lab/redis.tar.gz" -C "$redis_lab"
make -C "$redis_lab/redis-8.10.1" build redis -j2 MALLOC=libc
export REDIS_SERVER="$redis_lab/redis-8.10.1/src/redis-server"
python3 -m venv "$redis_lab/venv"
"$redis_lab/venv/bin/python" -m pip install redis==8.1.0

Run the Python block with "$redis_lab/venv/bin/python" in the same shell. It creates a private Unix socket under /tmp, disables TCP, scheduled snapshots, and append-only persistence, then stops only its own process and removes its runtime directory. Downloads require network access. No default local Redis is contacted.

from contextlib import contextmanager
import os
from pathlib import Path
import subprocess
from tempfile import TemporaryDirectory
import time

import redis
from redis.backoff import NoBackoff
from redis.retry import Retry


@contextmanager
def instance():
 with TemporaryDirectory(prefix="redis-lab-", dir="/tmp") as directory:
 endpoint = str(Path(directory) / "redis.sock")
 process = subprocess.Popen([
 os.environ["REDIS_SERVER"], "--port", "0",
 "--unixsocket", endpoint, "--unixsocketperm", "700",
 "--save", "", "--appendonly", "no", "--dir", directory,
 "--maxmemory-policy", "noeviction",
 ], stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
 client = redis.Redis(unix_socket_path=endpoint, decode_responses=False,
 socket_timeout=2, retry=Retry(NoBackoff(), 0))
 try:
 deadline = time.monotonic() + 5
 while True:
 assert process.poll() is None, "Redis exited during startup"
 try:
 if client.ping():
 break
 except redis.ConnectionError:
 if time.monotonic() >= deadline:
 raise
 time.sleep(0.02)
 yield client
 finally:
 client.close()
 if process.poll() is None:
 process.terminate()
 try:
 _, errors = process.communicate(timeout=5)
 except subprocess.TimeoutExpired:
 process.kill()
 process.communicate()
 raise
 assert process.returncode == 0, errors.decode()


with instance() as client:
 client.rpush("arrival", b"b", b"a", b"b")
 assert client.lrange("arrival", 0, -1) == [b"b", b"a", b"b"]
 assert client.lindex("arrival", 1) == b"a"
 assert client.llen("arrival") == 3
 client.zadd("ranked", {"b": 10})
 client.zadd("ranked", {"a": 10})
 assert client.zadd("ranked", {"b": 20}) == 0
 assert client.zcard("ranked") == 2
 assert client.zrange("ranked", 0, -1, withscores=True) == [(b"a", 10.0), (b"b", 20.0)]
 client.zadd("ranked", {"b": 10})
 assert client.zrange("ranked", 0, -1) == [b"a", b"b"]
 assert client.zrange("ranked", 0, -1, desc=True) == [b"b", b"a"]
 print("lists retain duplicates and positions; sorted sets update unique members and order ties by bytes")

 assert client.lpop("arrival") == b"b"
 assert client.rpop("arrival") == b"b"
 assert client.lrange("arrival", 0, -1) == [b"a"]
 client.rpush("fifo", b"old", b"new")
 client.rpush("lifo", b"old", b"new")
 assert client.lpop("fifo") == b"old"
 assert client.rpop("lifo") == b"new"
 print("RPUSH with LPOP removes oldest first; RPUSH with RPOP removes newest first")

 client.zadd("times", {"at-10": 10, "at-20": 20, "at-30": 30})
 assert client.zrange("times", 0, 1) == [b"at-10", b"at-20"]
 assert client.zrange("times", 10, 20, byscore=True) == [b"at-10", b"at-20"]
 assert client.zrange("times", "(10", 20, byscore=True) == [b"at-20"]
 assert client.zremrangebyscore("times", "-inf", "(20") == 1
 assert client.zrange("times", 0, -1) == [b"at-20", b"at-30"]
 assert client.ttl("times") == -1
 client.rpush("window", b"old", b"middle", b"new")
 client.ltrim("window", -2, -1)
 assert client.lrange("window", 0, -1) == [b"middle", b"new"]
 print("rank selects positions; score selects values; score cleanup and list trimming are explicit")

 now = 100
 client.zadd("schedule", {"future-job": now + 50})
 assert client.zrange("schedule", "-inf", now, byscore=True) == []
 assert client.zpopmin("schedule") == [(b"future-job", 150.0)]
 assert client.exists("schedule") == 0
 print("ZPOPMIN removes the minimum immediately even when its score represents a future deadline")

The list retains b, a, b as three entries and allows an interior LINDEX read. The sorted set contains only two members; updating b returns zero while changing its score. Equal-score ordering becomes a, b regardless of insertion order, and REV reverses it.

Separate FIFO and LIFO examples expose the choice of pop end. The range checks distinguish ranks from scores and inclusive from exclusive bounds. Score-based deletion removes only values below twenty, while a list trim retains its newest two values; the sorted-set key still has no expiration.

Finally, the numeric test clock is one hundred and the only scheduled score is one hundred fifty. The due-range query is empty, yet ZPOPMIN removes that future member immediately. This verifies command semantics, not a scheduler, memory comparison, crash-recovery protocol, or throughput benchmark.

Sources