Cụm bài Redis: 1. Redis bên trong: vì sao nhanh · 2. Persistence, replication, Sentinel và Cluster · 3. Chọn cấu trúc dữ liệu cho bài toán thật
Phần lớn code Redis trong dự án Java chỉ gọi opsForValue().set(key, json), bỏ phí lý do chính để chọn Redis: cấu trúc dữ liệu có lệnh chạy nguyên tử ngay trên server. Đọc xong, bạn biết mỗi kiểu dùng khi nào, giới hạn ở đâu, và thiết kế được hàng đợi trễ tự huỷ cuốc xe. Encoding và lệnh O(N) ở phần 1; hash tag và Cluster ở phần 2. Lệnh được chạy thử trên Redis 7.4.
Sơ đồ tóm tắt:
flowchart TD
A{"Bài toán là gì?"} -->|"Cache, đếm, lock"| B["String"]
A -->|"Sửa từng field"| C["Hash"]
A -->|"Hàng đợi không ack"| D["List"]
A -->|"Cần ack"| E["Stream"]
A -->|"Like, khử trùng"| F["Set"]
A -->|"Xếp hạng, hàng đợi trễ"| G["Sorted set"]
G --> H["Claim nguyên tử"]
H --> I["DB vẫn là nguồn sự thật"]
1. Câu hỏi mở đầu: hash hay chuỗi JSON?
Ý chính: hay đọc/sửa từng field thì dùng hash, vì mỗi lần sửa là một lệnh nguyên tử (chạy trọn vẹn, không ai chen vào giữa). Luôn đọc/ghi cả object thì chuỗi JSON đơn giản hơn.
Một object user {uid, username, email, age} có ba nhu cầu:
- C1: chỉ đọc
username(hiển thị ở header, gọi rất nhiều). - C2: chỉ cập nhật
age. - C3: lấy toàn bộ object.
# Cách A: chuỗi JSON
SET user:1 '{"uid":1,"username":"vinh","email":"vinh@example.com","age":33}'
# Cách B: hash
HSET user:1 uid 1 username vinh email vinh@example.com age 33
| Nhu cầu | Chuỗi JSON | Hash |
|---|---|---|
| C1 đọc username | GET cả chuỗi, parse ở app |
HGET user:1 username, chỉ gửi vài byte |
| C2 sửa age | GET, parse, sửa, SET lại: 2 round-trip và race |
HSET user:1 age 34: một lệnh, nguyên tử |
| C3 lấy hết | GET: một lệnh, deserialize thẳng thành object |
HGETALL, map field về object |
| Bộ nhớ (đo) | 136 byte | 112 byte (listpack) |
Quan trọng nhất là C2. Round-trip là một vòng gửi-nhận qua mạng; giữa hai vòng của JSON, request khác chen vào được và bên ghi sau đè mất thay đổi của bên kia. Với hash, mỗi HSET chỉ chạm field của nó.
2. String
Ý chính: string hợp với cache đã serialize, bộ đếm, session và lock. Bẫy hay gặp: ghép hai lệnh riêng (INCR rồi EXPIRE) mà tưởng là nguyên tử.
String cài bằng SDS, kiểu chuỗi riêng của Redis: binary safe, độ dài O(1), không tràn khi nối (xem phần 1). Tối đa 512 MB, nên giữ dưới 10 KB.
- Cache object hay response đã serialize (JSON, protobuf, nén).
- Bộ đếm:
INCR,INCRBY,INCRBYFLOATnguyên tử. Lượt xem, số lần gọi API, sinh ID tăng dần. - Session dùng chung giữa nhiều instance (Spring Session dùng hash, ý tưởng giống nhau).
- Distributed lock:
SET key token NX PX ttl. Rất nhiều bẫy; đọc bài review lock trước khi tự viết.
Ví dụ rate limiter cửa sổ cố định, tối đa 100 request mỗi phút mỗi user:
INCR rl:u1:202611181030 # trả 1 ở request đầu tiên của phút
EXPIRE rl:u1:202611181030 60 # app chỉ gọi khi INCR trả 1
3. List
Ý chính: list hợp với danh sách gần đây và hàng đợi đơn giản. Nó không có ack (xác nhận đã xử lý xong) và không có nhiều nhóm consumer; cần hai thứ đó thì dùng Stream.
List giữ chuỗi theo thứ tự chèn. Thêm/bớt ở hai đầu O(1) (LPUSH, RPUSH, LPOP, RPOP), đọc theo khoảng bằng LRANGE. Bên dưới là quicklist (danh sách liên kết các listpack).
- Danh sách gần đây: 10 bài viết mới nhất bằng
LPUSH+LTRIM 0 9; timeline đơn giản. - Hàng đợi: producer
LPUSH, consumerBRPOP(chặn chờ đến khi có phần tử).
BRPOP xoá phần tử trước khi app xử lý, nên consumer chết giữa chừng là mất message.
List làm hàng đợi: bốn giới hạn và cách vá bằng reliable queue
Giới hạn mà slide liệt kê, nói rõ hơn:
- Tối đa 2³² − 1 phần tử: hiếm khi là vấn đề thật; list đã thành big key từ lâu trước đó.
- Không có nhiều nhóm consumer: phần tử bị pop là biến mất, chỉ một consumer nhận. Muốn hai dịch vụ (gửi email, cập nhật thống kê) cùng nhận một sự kiện thì phải tự đẩy vào hai list.
- Không có ack: consumer
BRPOPxong rồi chết là mất message. - Thứ tự yếu khi nhiều consumer: list giữ đúng thứ tự, nhưng ba consumer chạy song song thì thứ tự hoàn thành không còn được đảm bảo.
Stream (Redis 5) là log chỉ nối đuôi có ID tăng dần. Nó vá các giới hạn của list bằng ba thứ:
- Consumer group: mỗi group nhận đủ mọi message, các consumer trong group chia nhau.
- Pending entries list: ghi nhớ message đã giao mà chưa
XACK. XAUTOCLAIM: consumer khác nhận lại message bị bỏ dở.
XADD orders * id o1 amount 250000 # producer
XGROUP CREATE orders billing 0 # nhóm "billing"
XREADGROUP GROUP billing c1 COUNT 10 BLOCK 5000 STREAMS orders >
XACK orders billing 1794975683643-0 # xử lý xong mới ack
XPENDING orders billing # message đã giao nhưng chưa ack
4. Hash
Ý chính: hash là map field → value trong một key. Mỗi thao tác trên một field là một lệnh nguyên tử, rất hợp làm giỏ hàng.
Encoding (cách Redis lưu bên dưới) là listpack khi nhỏ, hashtable khi lớn. Ba ứng dụng chính:
- Object hay đọc/sửa theo field (mục 1).
- Bộ đếm theo nhóm:
HINCRBY stats:2026-11-18 api_calls 1. - Giỏ hàng: một hash
cart:{userId}, field là mã sản phẩm, value là số lượng.
| Thao tác | Lệnh |
|---|---|
| Thêm sản phẩm | HSET cart:{u1} p100 1 |
| Tăng số lượng | HINCRBY cart:{u1} p100 2 (trả về 3) |
| Số dòng trong giỏ | HLEN cart:{u1} |
| Bỏ sản phẩm | HDEL cart:{u1} p200 |
| Số lượng của một sản phẩm | HGET cart:{u1} p100 |
| Cả giỏ | HGETALL cart:{u1} |
User bấm “thêm” trên hai tab cùng lúc vẫn đúng, không cần lock.
Giỏ hàng khi làm thật: TTL, giá, số lượng âm, hash tag
- Đặt TTL cho cả giỏ (
EXPIRE cart:{u1} 2592000, 30 ngày) và gia hạn mỗi lần user sửa, để giỏ bị bỏ rơi tự dọn. - Không lưu giá trong giỏ. Giá đọc từ catalog khi hiển thị và tính lại khi đặt hàng, nếu không user giữ giá cũ mãi.
HINCRBYvới số âm có thể đưa số lượng về 0 hoặc âm. Cần script Lua “giảm, nếu ≤ 0 thì xoá field” để giữ bất biến.- Hash tag
{u1}để các key khác của cùng user (checkout:{u1}) nằm cùng slot, nếu sau này cần thao tác chung trên Cluster.
5. Set
Ý chính: set là tập không thứ tự, phần tử duy nhất, hợp với like, khử trùng lặp và phép toán tập hợp. Phép toán trên tập lớn chặn luồng chính.
Encoding là intset khi toàn số nguyên nhỏ, listpack khi nhỏ, hashtable khi lớn.
- Khử trùng lặp:
SADDtrả 1 nếu phần tử mới, 0 nếu đã có. Đếm user duy nhất xem bài hôm nay, đánh dấu message đã xử lý. - Like:
SADD likes:post:9 u1,SISMEMBERđể biết đã like chưa,SCARDđể đếm. - Phép toán tập hợp: bạn chung
SINTER followers:a followers:b, gợi ýSDIFF, gộpSUNION. Từ 7.0,SINTERCARD 2 f:a f:b LIMIT 100chỉ đếm, không trả về cả tập. - Chọn ngẫu nhiên:
SRANDMEMBER,SPOPcho bốc thăm.
Giới hạn: tối đa 2³² − 1 phần tử. SINTER xấu nhất là O(N × M) (N: kích thước tập nhỏ nhất, M: số tập); SUNION/SDIFF là O(tổng số phần tử). Hai set triệu phần tử là hàng trăm ms chặn luồng chính.
6. Sorted set (ZSET)
Ý chính: mỗi phần tử có một score và tập luôn được sắp theo score, nên lấy top N hay “mọi thứ đến hạn trước bây giờ” rất rẻ.
Score là số thực 64 bit. Bên dưới là skiplist + dict (listpack khi nhỏ); skiplist là danh sách liên kết nhiều tầng, cho tìm kiếm O(log N). Đọc theo khoảng hạng hoặc khoảng score là O(log N + M).
Ứng dụng:
- Bảng xếp hạng, top N, hàng đợi ưu tiên.
- Hàng đợi trễ: score là thời điểm đến hạn (mục 8).
- Rate limiter cửa sổ trượt: score là timestamp mỗi request,
ZREMRANGEBYSCOREbỏ request cũ,ZCARDđếm. - Index phụ theo thời gian.
ZINCRBY lb:2026-11 50 alice # cộng điểm
ZREVRANGE lb:2026-11 0 9 WITHSCORES # top 10
ZREVRANK lb:2026-11 alice # hạng của tôi (từ 0)
ZSCORE lb:2026-11 alice
Cùng score thì xếp theo thứ tự từ điển của member, không theo ai đạt trước. Muốn tie-break (phân định khi bằng nhau) theo thời gian thì phải ghép timestamp vào score, và phải giữ score dưới 2⁵³.
Tie-break khi bằng điểm: kết quả chạy thử và giới hạn 2⁵³ của double
Chạy thử với alice 1500, bob 1500, carol 1800: ZREVRANGE trả carol, bob, alice; ZREVRANK của bob là 1, alice là 2. Hai người bằng điểm được xếp theo thứ tự từ điển ngược của tên.
7. Các kiểu ít gặp nhưng đáng biết
Ý chính: ngoài năm kiểu chính còn vài kiểu chuyên dụng; biết tên và bài toán của chúng là đủ.
| Kiểu | Dùng cho | Ví dụ |
|---|---|---|
| Bitmap | cờ theo ID số liên tục, điểm danh | SETBIT login:2026-11-18 34 1, BITCOUNT |
| HyperLogLog | đếm phần tử duy nhất xấp xỉ, 12 KB | PFADD uv:home u1, PFCOUNT uv:home |
| Geo | tìm theo bán kính | GEOADD, GEOSEARCH ... BYRADIUS 2 km |
| Stream | log/hàng đợi có consumer group và ack | mục 3 |
| Bitfield | nhiều bộ đếm nhỏ trong một chuỗi | BITFIELD |
8. Case study: tự huỷ cuốc xe sau 10 phút
Ý chính: dùng ZSET với member là orderId, score là thời điểm hết hạn. Worker phải “claim” (nhận quyền xử lý) nguyên tử, và lệnh huỷ trong DB phải có điều kiện, vì Redis không phải nguồn sự thật.
8.1. Bài toán
Khách đặt cuốc; sau 10 phút không tài xế nào nhận thì hệ thống tự huỷ và báo “hiện chưa có tài xế”. Ràng buộc:
- Cao điểm vài nghìn cuốc mỗi phút; huỷ trễ vài giây chấp nhận được.
- Không được huỷ hai lần (gửi hai thông báo, hoàn tiền hai lần) và không được bỏ sót cuốc nào.
- Dịch vụ chạy nhiều instance.
8.2. Các lựa chọn
Bài này chọn ZSET: nhanh, chia sẻ được giữa các instance. Đổi lại phải tự lo claim nguyên tử, crash và idempotency (chạy nhiều lần vẫn như một lần). Nếu tải cho phép, quét DB đơn giản hơn và nên xét trước.
Bảng so sánh 5 cách làm hàng đợi trễ và lựa chọn cuối cùng
| Cách | Ưu | Nhược |
|---|---|---|
Quét DB mỗi giây WHERE status = 'WAITING' AND created_at < now() - 10 phút |
Đơn giản, nguồn sự thật duy nhất | Tải DB đều đặn, cần index, nhiều instance cùng quét phải khoá (SKIP LOCKED) |
| Key Redis TTL 10 phút + keyspace notification khi hết hạn | Không phải quét | Notification là pub/sub không đảm bảo: subscriber mất kết nối là mất sự kiện; key hết hạn có thể trễ |
@Scheduled/timer trong bộ nhớ từng instance |
Không cần hạ tầng | Mất hết khi restart, không chia việc giữa instance |
| Message broker có delay (RabbitMQ delayed exchange, SQS delay tối đa 15 phút) | Đúng bài, có ack | Thêm hạ tầng; Kafka không có delay sẵn |
ZSET: member là orderId, score là thời điểm hết hạn |
Nhanh, chia sẻ giữa instance, lấy theo thời gian O(log N) | Phải tự lo claim nguyên tử, crash, idempotency |
8.3. Thiết kế bằng ZSET
ZADD order:pending-timeout 1794976290000 order-o1 # score = now + 10 phút (ms)
ZREM order:pending-timeout order-o1 # tài xế nhận cuốc: gỡ khỏi hàng đợi
Mỗi instance có một worker lặp: lấy các cuốc có score ≤ bây giờ rồi huỷ. Cách viết đầu tiên ai cũng nghĩ ra:
List<String> due = redis.zrangeByScore(KEY, "-inf", now, 0, 50); // 1. đọc các cuốc đến hạn
redis.zrem(KEY, due.toArray(String[]::new)); // 2. xoá
due.forEach(this::cancelOrder); // 3. huỷ
Bước 1 và 2 tách rời: bốn worker cùng đọc trước khi ai kịp xoá sẽ nhận cùng một danh sách. Đo với 2.000 cuốc hết hạn rải trong 1 giây, 4 worker, Jedis 5.2 trên Redis 7.4:
naive processed=2000 distinct, duplicates=784, left=0
atomic processed=2000 distinct, duplicates=0, left=0
784 cuốc bị huỷ hơn một lần. Bản atomic gộp đọc và xoá vào một script Lua, chạy nguyên tử trên server:
static final String CLAIM = """
local due = redis.call('ZRANGE', KEYS[1], '-inf', ARGV[1], 'BYSCORE', 'LIMIT', 0, ARGV[2])
if #due > 0 then redis.call('ZREM', KEYS[1], unpack(due)) end
return due
""";
@SuppressWarnings("unchecked")
List<String> claimDue(long nowMs, int batch) {
return (List<String>) redis.eval(CLAIM, List.of(KEY), List.of(String.valueOf(nowMs), String.valueOf(batch)));
}
Hai cách khác không cần Lua:
- Sau
ZRANGEBYSCORE, gọiZREMtừng member, chỉ xử lý member nàoZREMtrả 1 (ai xoá được thì người đó sở hữu). Đúng, nhưng mỗi cuốc một round-trip. ZPOPMINcũng nguyên tử, nhưng lấy cả phần tử chưa đến hạn nếu không kiểm tra score.
8.4. Những gì còn có thể hỏng
Claim nguyên tử mới chặn được xử lý trùng. Hai lỗ hổng lớn nhất còn lại:
- Worker crash sau khi claim, trước khi huỷ: phần tử đã rời ZSET, cuốc nằm
WAITINGmãi. Vá bằng visibility timeout: claim chuyển phần tử sang ZSETprocessingvới score = bây giờ + 60 giây thay vì xoá hẳn. Xong việc mớiZREM processing; một job đẩy lại phần tử quá hạn. Hoặc quét DB thưa (mỗi 5 phút) tìm cuốcWAITINGquá 11 phút. - Tài xế nhận cuốc đúng lúc worker huỷ:
ZREMcủa luồng nhận và claim của worker đua nhau. Nguồn sự thật phải là DB, lệnh huỷ phải có điều kiện:UPDATE ride SET status = 'CANCELLED' WHERE id = ? AND status = 'WAITING'. 0 dòng bị ảnh hưởng nghĩa là tài xế đã nhận trước, bỏ qua. Lệnh nhận cuốc có điều kiện ngược lại, nên handler idempotent dù chạy trùng.
Bốn chỗ hỏng còn lại: thông báo trùng, lệch đồng hồ, mất dữ liệu Redis, ZSET khổng lồ
- Thông báo gửi hai lần: chỉ gửi sau khi
UPDATEthành công (số dòng = 1), tốt nhất qua outbox để không mất khi crash giữa chừng. - Đồng hồ các instance lệch nhau: worker dùng giờ máy mình để so score. Lệch vài trăm ms chỉ làm huỷ sớm/muộn chút; lệch lớn thì dùng
TIMEcủa Redis làm mốc chung. - Mất dữ liệu Redis (failover bất đồng bộ, flush nhầm): lưới an toàn quét DB ở bước 1 cũng cứu trường hợp này. Đây là lý do Redis không nên là nơi duy nhất biết “cuốc nào cần huỷ”.
- Một ZSET khổng lồ trên Cluster là một key trên một node. Nếu hàng triệu phần tử, chia thành nhiều key theo bucket (
order:pending-timeout:{0..15}theo hash của orderId), mỗi worker quét các bucket.
Khi timer bị đặt lại liên tục (1 triệu thiết bị gửi heartbeat, ~333K lần mỗi giây), mỗi lần là một round trip tới Redis; so sánh ZSET với timing wheel trong bộ nhớ ở Hệ thống liveness: từ Redis sorted set đến timing wheel và LMAX Disruptor.
9. Thói quen tốt khi dùng Redis
Ý chính: ít round-trip, không chạy việc dài trên server, key nào cũng có kích thước và TTL được kiểm soát.
- Giảm round-trip:
MGET/MSET,HMGETvà pipeline (gửi nhiều lệnh, không chờ trả lời từng cái). 100 lệnhGETtuần tự với RTT 0,5 ms là 50 ms; một pipeline khoảng 1 ms. Pipeline không nguyên tử; cần nguyên tử thìMULTI/EXEChoặc Lua. - Không chạy việc dài trên server: script Lua lặp lớn, lệnh O(N) trên tập lớn (mục 5, phần 1).
- TTL ngắn cho cache, và rải TTL bằng jitter để không hết hạn đồng loạt (sự cố cache).
- Tránh big key: string trên 10 KB hoặc collection trên 5.000 phần tử đã đáng xem lại. Tìm bằng
redis-cli --bigkeys,--memkeys,MEMORY USAGE; xoá bằngUNLINKthay vìDEL(mục big key). - Biết trần của một node: khoảng 50K SET/giây, 80K GET/giây khi không pipeline, nên giữ mỗi instance ≤ 32 GB; con số và case study bộ đếm 1 triệu QPS ở Cache nhiều tầng và bộ đếm quy mô lớn.
Thêm bốn thói quen và bảng độ phức tạp của các lệnh hay dùng
- Chọn đúng cấu trúc thay vì nhét mọi thứ vào chuỗi JSON.
- Hash tag cho nhóm key cần thao tác chung trên Cluster (phần 2).
- Biết độ phức tạp của lệnh trước khi dùng; tài liệu Redis ghi rõ cho từng lệnh.
- Đặt tên key có cấu trúc:
service:entity:{id}:field, ngắn vừa đủ, dễ tìm và dễ phân quyền bằng ACL theo prefix.
| Lệnh | Độ phức tạp | Ghi chú |
|---|---|---|
GET, SET, HGET, SADD, SISMEMBER |
O(1) | an toàn |
ZADD, ZRANK, ZREM |
O(log N) | an toàn |
ZRANGE ... LIMIT, LRANGE nhỏ |
O(log N + M) | M nhỏ thì an toàn |
HGETALL, SMEMBERS, LRANGE 0 -1 |
O(N) | chỉ dùng khi biết N nhỏ |
SINTER, SUNION, SORT |
O(N·M) hoặc hơn | cẩn thận trên tập lớn |
KEYS, FLUSHALL (đồng bộ) |
O(N toàn keyspace) | cấm trên production |
Bài tập
Bài 1: bảng xếp hạng tháng có tie-break
Đề: game có bảng xếp hạng theo tháng. Cần top 10, hạng của người chơi hiện tại, và khi bằng điểm thì ai đạt điểm đó trước xếp trên. Điểm tối đa 100.000. Bảng tháng cũ giữ 3 tháng rồi xoá.
Lời giải Bài 1: score ghép điểm và timestamp, cộng điểm bằng Lua
- Key
lb:{2026-11}, member làplayerId. Score =điểm × 10^10 + (9_999_999_999 − epochSecond lúc đạt điểm). Với điểm ≤ 100.000, score tối đa khoảng 10¹⁵ + 10¹⁰ < 2⁵³, nên double vẫn chính xác. - Cộng điểm không dùng được
ZINCRBY(vì phải cập nhật cả phần timestamp), nên dùng Lua: đọc score cũ, tách điểm (math.floor(score / 1e10)), cộng điểm mới, ghép timestamp hiện tại,ZADD. Chạy nguyên tử trên server. - Top 10:
ZREVRANGE lb:{2026-11} 0 9 WITHSCORES, rồi app tách điểm ra để hiển thị. Hạng của tôi:ZREVRANK+ 1. - Dọn dẹp:
EXPIREAT lb:{2026-11}đặt vào cuối tháng thứ 3 sau đó. Nếu một tháng có hàng chục triệu người chơi, key này là big key: cân nhắc chỉ giữ top 10.000 bằngZREMRANGEBYRANK lb 0 -10001định kỳ và lưu điểm đầy đủ ở DB.
Bài 2: distributed lock cho hai request đặt cùng một ghế
Đề (bài tập về nhà của buổi Redis, diễn giải): hai request cùng lúc đặt ghế A34_S012C trên chuyến FA634; dùng Redis lock để chỉ một request được xử lý, không cần cài DB và logic đặt chỗ.
Lời giải đầy đủ có code Java chạy được nằm ở bài review distributed lock, bài tập 3.
Lời giải Bài 2: các điểm chính
Code dùng Jedis, SET NX PX + mở khoá bằng Lua so token; chạy 200 vòng × 8 request đều chỉ một request đặt được.
- Khoá theo đúng tài nguyên:
lock:seat:FA634:A34_S012C. - Token ngẫu nhiên, mở khoá có so token.
- Kiểm tra lại trạng thái ghế sau khi có khoá.
- Trong hệ thống thật, câu lệnh có điều kiện trong DB vẫn là hàng rào cuối cùng.
Ghi nhớ
- Giải thích được vì sao đọc-sửa-ghi trên chuỗi JSON làm mất cập nhật, còn
HSETthì không. - Biết khi nào List đủ làm hàng đợi, khi nào cần Stream hoặc broker thật.
- Viết được claim nguyên tử cho hàng đợi trễ bằng ZSET, và nhớ con số 784/2.000.
- Kể được hai lỗ hổng còn lại sau claim nguyên tử (crash sau claim, đua với tài xế) và cách vá.
- Biết lệnh nào O(N) trở lên và vì sao nó chặn mọi client.
Câu hỏi phỏng vấn
Junior
Kể các kiểu dữ liệu chính của Redis và một ứng dụng của mỗi kiểu.
Năm kiểu chính: String, List, Hash, Set, Sorted set; mỗi kiểu có lệnh riêng chạy nguyên tử trên server.
- String: cache JSON, bộ đếm, khoá.
- List: danh sách gần đây, hàng đợi đơn giản.
- Hash: object theo field, giỏ hàng.
- Set: like, khử trùng lặp, bạn chung.
- Sorted set: bảng xếp hạng, hàng đợi trễ.
Ngoài ra có Stream (hàng đợi có ack và consumer group), Bitmap, HyperLogLog, Geo.
Làm giỏ hàng bằng Redis thế nào?
Mỗi giỏ là một hash cart:{userId}, field là mã sản phẩm, value là số lượng.
HSET để thêm, HINCRBY để tăng, HDEL để bỏ, HGETALL để lấy cả giỏ, HLEN để đếm dòng. Mỗi thao tác là một lệnh nguyên tử. Đặt TTL cho giỏ bỏ rơi và không lưu giá trong giỏ.
Mid
Lưu một object user bằng hash hay chuỗi JSON?
Hash nếu hay đọc/sửa từng field; chuỗi JSON nếu luôn đọc/ghi cả object.
Với hash, HSET một field là nguyên tử, nhiều writer sửa field khác nhau không gây lost update, và hash nhỏ gọn hơn. Chuỗi JSON hợp khi object lồng nhiều tầng hoặc là cache của response đã serialize. Sửa JSON theo kiểu đọc-sửa-ghi phải có Lua hoặc WATCH; RedisJSON là lựa chọn thứ ba.
Vì sao dùng List làm hàng đợi có thể mất message, và thay bằng gì?
Vì BRPOP xoá phần tử trước khi consumer xử lý, consumer chết là mất; thay bằng Stream.
List không có ack, không có nhiều consumer group. Vá được bằng BLMOVE sang list processing kèm job dọn dẹp. Tốt hơn là Stream: consumer group, pending list, XACK, XAUTOCLAIM. Khối lượng lớn hoặc cần bền thật thì dùng Kafka/RabbitMQ.
Làm hàng đợi trễ bằng Redis thế nào cho nhiều worker không xử lý trùng?
ZSET với score là thời điểm đến hạn, và worker phải claim nguyên tử.
Claim bằng script Lua ZRANGE BYSCORE ... LIMIT rồi ZREM trong cùng lệnh, hoặc chỉ xử lý phần tử mà ZREM của mình trả 1. Đọc rồi xoá ở hai lệnh riêng cho ra xử lý trùng (đo được 784/2.000 với 4 worker). Thêm visibility timeout cho crash, và handler idempotent bằng câu lệnh có điều kiện trong DB.
Pipeline khác MULTI/EXEC thế nào?
Pipeline giảm round-trip nhưng không nguyên tử; MULTI/EXEC là transaction phía server, chạy liền một khối.
Pipeline là kỹ thuật phía client: gửi nhiều lệnh một lượt không chờ từng reply, nên lệnh của client khác vẫn xen vào được. MULTI/EXEC xếp hàng các lệnh rồi chạy liền không bị xen, nhưng không rollback nếu một lệnh lỗi khi chạy. Hay dùng kết hợp: gửi MULTI ... EXEC trong một pipeline.
Senior
Thiết kế bảng xếp hạng cho 50 triệu người chơi, cần top 100 và hạng của từng người.
Sorted set cho phần top, nhưng không nhét cả 50 triệu người vào một ZSET.
Một ZSET 50 triệu phần tử là big key (vài GB, một node, fork nặng). Giữ ZSET chỉ cho top N (vài chục nghìn), cắt bớt định kỳ. Hạng của người ngoài top tính từ DB, hoặc xấp xỉ từ phân phối điểm (đếm theo bucket điểm, “bạn nằm trong top 12%”). Tie-break mã hoá vào score với giới hạn 2⁵³. Chia theo mùa/khu vực để mỗi key vừa phải.
Khi nào không nên dùng Redis cho một bài toán dữ liệu?
Khi Redis phải là nguồn sự thật duy nhất cho dữ liệu không được mất.
- Lệnh ghi đã xác nhận không được mất (tiền, tồn kho): replication của Redis bất đồng bộ.
- Dữ liệu không vừa RAM với chi phí hợp lý.
- Cần truy vấn linh hoạt, join, transaction nhiều thực thể.
- Cần giữ message lâu và đọc lại nhiều lần (Kafka).
Redis tốt nhất là lớp tăng tốc hoặc trạng thái tạm, với nguồn sự thật ở chỗ khác.
Hàng đợi trễ bằng ZSET: worker crash ngay sau khi claim thì sao?
Phần tử đã rời ZSET nên việc bị bỏ, trừ khi claim có visibility timeout.
Thay vì xoá hẳn, script claim chuyển phần tử sang ZSET processing với score là hạn chót xử lý. Xong việc mới xoá; một job trả lại phần tử quá hạn. Handler phải idempotent (câu lệnh có điều kiện theo trạng thái) vì có thể chạy lại. Thêm lưới an toàn quét DB thưa, vì Redis cũng có thể mất dữ liệu khi failover.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu tiếng Anh dùng trong phỏng vấn |
|---|---|---|---|
| round-trip | /ˈraʊnd trɪp/ | một vòng gửi-nhận qua mạng | “A hash lets us update one field in a single round-trip.” |
| lost update | /lɒst ˈʌpdeɪt/ | cập nhật bị ghi đè mất | “Read-modify-write on a JSON blob causes lost updates under concurrency.” |
| tie-break | /ˈtaɪ breɪk/ | quy tắc phân định khi bằng nhau | “We encode the timestamp into the score as a tie-break.” |
| claim | /kleɪm/ | nhận quyền xử lý | “Workers claim due items atomically with a Lua script.” |
| visibility timeout | /ˌvɪzəˈbɪləti ˈtaɪmaʊt/ | thời hạn trước khi việc được giao lại | “If a worker dies, the item reappears after the visibility timeout.” |
| idempotent | /ˌaɪdemˈpəʊtənt/ | chạy nhiều lần như một lần | “The cancel handler is idempotent thanks to a conditional update.” |
| consumer group | /kənˈsjuːmə ɡruːp/ | nhóm consumer chia nhau message | “Streams give us consumer groups and acknowledgements.” |
| pipeline | /ˈpaɪplaɪn/ | gửi nhiều lệnh một lượt | “Pipelining cut the latency of the batch from fifty milliseconds to one.” |
Ghi chép dựa trên khoá Advanced Backend (Ronin Engineer), viết lại theo cách hiểu của mình.