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
“Redis đơn luồng thì sao nhanh được?” gần như luôn có trong phỏng vấn backend, và “vì chạy trên RAM” chỉ được nửa điểm. Bài này giải thích nửa còn lại: event loop, cách lưu key, cách dọn key hết hạn, và vì sao một lệnh KEYS * có thể làm cả hệ thống đứng hình. Đây là phần 1; phần 2 nói về độ bền và mở rộng (RDB, AOF, replication, Sentinel, Cluster), phần 3 về chọn cấu trúc dữ liệu, còn sự cố cache (avalanche, hot key, big key, eviction) có ở bài sự cố cache.
Số liệu trong bài đo trên Redis 7.4 chạy bằng Docker, cấu hình mặc định.
1. Redis là gì, và khác Memcached ở đâu
Ý chính: Redis là kho key-value nằm trong RAM, mà value có kiểu và có lệnh chạy ngay trên server. Memcached chỉ lưu chuỗi byte, đa luồng, không persistence và không replication sẵn.
Kiểu value gồm string, list, hash, set, sorted set, stream, bitmap, HyperLogLog, geo. Muốn thêm một phần tử vào list thì gửi RPUSH, không phải kéo cả list về app. Ngoài ra có transaction (MULTI/EXEC), script Lua và function, pub/sub, persistence, replication, cluster, và chính sách eviction (bỏ bớt key) khi đầy bộ nhớ.
| Redis | Memcached | |
|---|---|---|
| Mô hình thực thi lệnh | Một luồng chạy lệnh (thêm luồng I/O tuỳ chọn từ bản 6) | Đa luồng |
| Kiểu dữ liệu | Nhiều kiểu, thao tác trên server | Chỉ chuỗi byte |
| Persistence | RDB, AOF | Không |
| Replication, failover | Có (replica, Sentinel, Cluster) | Không có sẵn |
| Chia dữ liệu nhiều node | Redis Cluster (server biết slot) | Client tự băm (consistent hashing) |
| Giới hạn value | 512 MB cho string | Mặc định 1 MB mỗi item |
| Tính năng thêm | Lua, transaction, pub/sub, stream | Gần như không |
Hai chỗ slide nói chưa đúng: “Memcached không có cluster” và “Redis quá 16 GB thì chậm”
2. Vì sao Redis nhanh
Ý chính: dữ liệu ở RAM, một luồng chạy lệnh nên không cần lock, một event loop theo dõi hàng chục nghìn socket, và cấu trúc dữ liệu được tối ưu. Cái giá: mọi lệnh xếp hàng nối tiếp, nên một lệnh chậm làm chậm tất cả.
2.1. Nút thắt không phải là CPU
Một GET trên hash table trong RAM tốn vài trăm nano giây CPU. Một vòng request qua mạng trong cùng data center tốn 100–500 micro giây. Nên phần lớn thời gian nằm ở mạng và syscall đọc/ghi socket, không phải ở chạy lệnh.
Khi Redis chạm trần, thường là vì:
- Bộ nhớ: dữ liệu không vừa RAM, phải evict hoặc lỗi OOM.
- Băng thông mạng: value to nhân số lượt đọc vượt card mạng (big key).
- Một lệnh chậm chặn tất cả: lệnh O(N) trên tập lớn, script Lua dài.
CPU chỉ thành nút thắt khi rất nhiều kết nối gửi lệnh nhỏ. Lúc đó phần tốn CPU lại là đọc/ghi socket, đúng thứ io-threads ở bản 6 sinh ra để gánh.
2.2. Bốn lý do
- Dữ liệu ở RAM: không có disk seek trên đường đọc. Persistence (nếu bật) chạy ở tiến trình con hoặc ghi nối đuôi.
- Một luồng chạy lệnh: không lock, không context switch (CPU đổi qua lại giữa các luồng), không race condition bên trong server. Mỗi lệnh tự nguyên tử, nên
INCRan toàn mà không cần gì thêm. - I/O multiplexing: một luồng theo dõi nhiều socket cùng lúc bằng
epoll(Linux) hoặckqueue(macOS/BSD), chỉ xử lý socket đã có dữ liệu. - Cấu trúc dữ liệu tối ưu: tập nhỏ lưu nén liên tục (listpack, intset), tập lớn dùng hash table, skiplist. Xem mục 3.
2.3. Event loop trông như thế nào
Event loop là vòng lặp vô tận: hỏi kernel “socket nào sẵn sàng”, rồi xử lý từng cái. Giống người phục vụ chỉ đến bàn nào giơ tay, thay vì đứng chờ ở từng bàn.
flowchart LR
C1[Client 1] --> E[epoll_wait]
C2[Client 2] --> E
C3[Client N] --> E
E --> R[Đọc và parse lệnh]
R --> X[Thực thi lệnh trên keyspace]
X --> W[Ghi reply vào buffer]
W --> S[Gửi reply về socket]
S --> T[Timer: active expire, cron]
T --> E
Cuối mỗi vòng là việc định kỳ serverCron, chạy với tần suất hz (mặc định 10 lần/giây): xoá key hết hạn chủ động, resize hash table, thống kê. Vì chỉ một luồng chạy lệnh, một lệnh mất 200 ms là 200 ms mọi client khác đứng chờ.
2.4. “Đơn luồng” chính xác là gì
Slide nói “sau bản 6.0 Redis không còn đơn luồng”. Ý đúng, nhưng khi phỏng vấn cần nói chính xác:
- Thực thi lệnh vẫn đơn luồng, kể cả ở Redis 7. Đây là thứ đảm bảo mỗi lệnh nguyên tử.
- io-threads (6.0) là tuỳ chọn, mặc định tắt (
io-threads 1). Bật lên thì thêm luồng đọc/parse request và ghi reply, còn chạy lệnh vẫn ở luồng chính. - Persistence dùng tiến trình con, không phải luồng:
BGSAVEvà rewrite AOF gọifork(). Chi tiết ở phần 2.
Muốn dùng nhiều core cho chạy lệnh thì chạy nhiều instance trên một máy (mỗi instance một shard) hoặc dùng Redis Cluster.
Luồng nền bio, io-threads chi tiết và chuyện giấy phép Redis/Valkey
Câu đầy đủ của slide: “luồng chính chạy lệnh, các luồng khác lo persistence và network I/O”. Phần “persistence” cần sửa như trên. Thêm vài chi tiết:
- Luồng nền (bio) có từ trước bản 6 rất lâu: đóng file,
fsyncAOF, giải phóng bộ nhớ của key bị xoá bằngUNLINK(lazyfree). - io-threads có ích khi rất nhiều kết nối và CPU luồng chính bị syscall ăn hết. Redis 8 làm lại cơ chế này để tận dụng nhiều core tốt hơn.
3. Redis lưu dữ liệu thế nào
Ý chính: keyspace là một hash table (key → value) cộng một dict expires cho key có TTL. Mỗi value có kiểu và encoding (cách lưu bên dưới); tập nhỏ được lưu nén, lớn lên thì Redis tự chuyển sang cấu trúc nhanh hơn nhưng tốn bộ nhớ hơn.
3.1. Keyspace là một hash table
Mỗi database của Redis (mặc định 16, số 0–15; Cluster chỉ dùng số 0) có:
- một dict chính: key → value,
- một dict
expires: key → thời điểm hết hạn (ms), chỉ chứa key có TTL.
flowchart LR
DB[redisDb] --> D[dict: key -> redisObject]
DB --> EX[expires: key -> unix ms]
D --> O1[redisObject type=hash encoding=listpack]
D --> O2[redisObject type=string encoding=int]
EX --> T1[1735689600000]
Tra key là O(1) trung bình. Value là một redisObject mang kiểu (string, list, hash…) và encoding. Một kiểu có thể có nhiều encoding.
Hash table rehash dần dần: khi mở rộng, Redis giữ hai bảng song song, mỗi lệnh chuyển vài bucket sang bảng mới. Nhờ vậy không có lần resize nào dừng cả server, như khi một HashMap Java khổng lồ resize.
3.2. Encoding: nhỏ thì nén, lớn thì chuyển
listpack là một mảng byte liên tục, các phần tử nối nhau, không con trỏ. Tìm một field là quét O(N), nhưng với N nhỏ và dữ liệu nằm gọn trong cache CPU thì nhanh hơn hash table và tốn ít bộ nhớ hơn nhiều. Giống một tờ giấy ghi danh sách ngắn: đọc lướt còn nhanh hơn tra mục lục.
Mình đo một hash 512 field (vẫn listpack) và 513 field (đã sang hashtable), cùng nội dung ngắn:
512 field, listpack -> MEMORY USAGE = 5,168 byte
513 field, hashtable -> MEMORY USAGE = 28,816 byte
Thêm một field làm bộ nhớ tăng 5,6 lần. Vì vậy mẹo cổ điển vẫn hiệu quả: thay vì 10 triệu key user:{id}:status, gom thành các hash nhỏ user:status:{id / 1000} mỗi hash ≤ 512 field. Mỗi key top-level tốn thêm overhead của dict entry, redisObject và chuỗi key, nên gom lại tiết kiệm rất nhiều.
Bảng encoding và ngưỡng mặc định của Redis 7.4, và ziplist cũ
Bảng dưới là những gì OBJECT ENCODING trả về trên Redis 7.4. Ngưỡng đọc bằng CONFIG GET trên image Docker không kèm file cấu hình; redis.conf hay dịch vụ managed có thể đặt khác, nên hãy kiểm tra trên instance của bạn.
| Kiểu | Khi nhỏ | Khi lớn | Ngưỡng mặc định (7.4) |
|---|---|---|---|
| String | int (số nguyên), embstr (≤ 44 byte) |
raw |
44 byte |
| List | listpack |
quicklist (danh sách liên kết các listpack) |
list-max-listpack-size -2 (8 KB mỗi node) |
| Hash | listpack |
hashtable |
512 field, value ≤ 64 byte |
| Set | intset (toàn số), listpack |
hashtable |
512 số / 128 phần tử |
| Sorted set | listpack |
skiplist + dict |
128 phần tử, value ≤ 64 byte |
Bản trước 7.0 dùng ziplist. Nó có lỗi “cascade update”: sửa một phần tử có thể phải sửa dây chuyền các phần tử sau. listpack thay nó.
3.3. SDS: chuỗi của Redis
Redis không dùng chuỗi C kết thúc bằng \0 mà dùng SDS (Simple Dynamic String): một header chứa độ dài đã dùng và dung lượng đã cấp, theo sau là các byte. Nhờ vậy string binary safe (lưu được mọi byte, kể cả 0) và lấy độ dài O(1).
3.4. Skiplist cho sorted set
Sorted set lớn dùng hai cấu trúc cùng lúc: một dict (member → score) để ZSCORE O(1), và một skiplist sắp theo score để ZRANGE, ZRANK O(log N).
Skiplist là danh sách liên kết có nhiều tầng “đường cao tốc”: tầng dưới chứa mọi phần tử theo thứ tự, mỗi tầng trên chứa một phần ngẫu nhiên của tầng dưới. Tìm kiếm đi từ tầng cao nhất, nhảy xa nhất có thể rồi xuống tầng.
tầng 2: 1 ----------------- 9 ----------------- 31
tầng 1: 1 ------ 4 ------- 9 ------ 18 ------- 31
tầng 0: 1 - 2 -- 4 -- 6 -- 9 - 13 - 18 - 25 -- 31
SDS và skiplist từ bên trong, và skiplist so với cây cân bằng
SDS chi tiết:
- Binary safe: lưu được byte
0, nên string chứa được ảnh, protobuf, dữ liệu nén. - Lấy độ dài O(1) (
STRLEN) thay vì đếm đến\0. - Không tràn bộ đệm khi nối:
APPENDkiểm tra dung lượng và cấp phát thêm trước khi ghi. Nó cấp dư (gấp đôi khi còn nhỏ, thêm 1 MB khi đã lớn) để nối nhiều lần không phải realloc mỗi lần. embstrlà tối ưu cho chuỗi ngắn:redisObjectvà SDS nằm trong một lần cấp phát liên tục (một cache line), thay vì hai.
Skiplist chi tiết: Redis dùng xác suất 1/4 để một node lên tầng trên, tối đa 32 tầng. Vì sao không dùng cây cân bằng? Skiplist đơn giản hơn để cài và debug, range query chỉ là đi tiếp ở tầng 0, và mỗi liên kết lưu thêm “span” để tính rank O(log N).
4. Key hết hạn bị xoá như thế nào
Ý chính: Redis không xoá key đúng lúc hết hạn. Nó xoá thụ động khi có lệnh chạm vào key, và chủ động bằng một vòng lấy mẫu chạy 10 lần/giây, để key không ai đọc cũng không chiếm RAM mãi.
4.1. Kiểm tra hết hạn
SET k v EX 60 ghi k vào dict chính và k → now + 60000 vào expires. Khi một lệnh chạm vào k, Redis tra expires:
- không có: key không có TTL, đọc bình thường;
- có, đã quá hạn: xoá rồi trả về như thể không tồn tại (
nil); - có, chưa đến hạn: đọc bình thường.
Nếu chỉ dựa vào lần đọc, key “chết” mà không ai đọc sẽ chiếm RAM mãi. Vì vậy Redis kết hợp hai cách.
4.2. Xoá thụ động (lazy) và xoá chủ động (active)
- Thụ động: xoá khi có người chạm vào. Rẻ, nhưng không bao giờ xoá được key không ai đọc.
- Chủ động: mỗi vòng cron, hàm
activeExpireCyclelấy một nhóm key có TTL (mặc định 20), xoá key đã hết hạn. Nếu hơn 25% nhóm đã hết hạn thì lặp lại, nếu không thì chờ vòng sau.
Hệ quả: ở trạng thái ổn định, tỷ lệ key đã hết hạn mà còn nằm trong RAM dao động quanh 25%. Muốn dọn mạnh hơn thì tăng active-expire-effort (1–10, mặc định 1), đổi lấy CPU.
activeExpireCycle chi tiết, thí nghiệm 20.000 key và hai chỗ slide sai
Các bước của vòng chủ động:
- Lấy một nhóm key có TTL (mặc định 20 key) từ
expires. - Xoá những key đã hết hạn trong nhóm.
- Nếu hơn 25% số key lấy ra đã hết hạn (còn nhiều rác), lặp lại bước 1; nếu không, dừng chờ vòng sau.
- Có giới hạn thời gian (khoảng 25% thời gian CPU mỗi vòng) để không chặn lệnh của client. Ngoài vòng “chậm” này còn có vòng “nhanh” tối đa 1 ms chạy trước mỗi lần quay lại event loop.
Thí nghiệm: ghi 20.000 key TTL 1 giây, không đọc lại key nào. Sau 3 giây DBSIZE từ 20.004 xuống 4, INFO stats báo expired_keys:20000 và expire_cycle_cpu_milliseconds:11. Không ai đọc mà vẫn sạch, nhờ vòng chủ động.
4.3. Hết hạn trên replica và khi khởi động lại
- Replica không tự xoá key hết hạn. Master xoá key thì sinh lệnh
DELvà ghi vào stream replication, AOF; replica chờ lệnh đó. Từ 3.2, đọc trên replica một key đã quá hạn thì nhậnnildù chưa xoá, nên client không thấy dữ liệu cũ; nhưng bộ nhớ chỉ được giải phóng khiDELtới. - TTL là thời điểm tuyệt đối (unix ms): master bỏ qua key đã quá hạn khi nạp RDB, và chỉnh đồng hồ hệ thống làm key hết hạn sớm hay muộn tương ứng.
5. Khi bộ nhớ đầy
Ý chính: chạm maxmemory thì Redis làm theo maxmemory-policy. Mặc định noeviction từ chối lệnh ghi (lỗi OOM command not allowed), đọc vẫn được; các policy khác bỏ bớt key theo random, TTL, LRU hoặc LFU.
- Mỗi nhóm có bản
allkeys-*(xét mọi key) vàvolatile-*(chỉ key có TTL). Nhóm TTL bỏ key sắp hết hạn trước. - LRU (bỏ key lâu không dùng nhất) của Redis là xấp xỉ: lấy mẫu
maxmemory-samples(mặc định 5) key rồi bỏ key cũ nhất, không giữ danh sách liên kết toàn cục. - LFU (bỏ key ít dùng nhất) dùng bộ đếm logarit 8 bit, giảm dần theo thời gian.
Bảng đầy đủ, so sánh với W-TinyLFU của Caffeine, và bẫy volatile-* với key không TTL có ở bài sự cố cache, mục 7.
Bài tập
Bài 1: ước lượng bộ nhớ cho 10 triệu cờ trạng thái
Đề: lưu trạng thái online/offline cho 10 triệu user (user_id là số liên tục). Cách A: 10 triệu key online:{id} giá trị 1. Cách B: gom thành hash online:{id / 500} với field là id % 500. Cách C: một bitmap SETBIT online {id} 1. So sánh bộ nhớ và thao tác.
Lời giải Bài 1: so sánh ba cách lưu
- A: mỗi key top-level tốn khoảng 50–70 byte (dict entry,
redisObject, SDS cho key, giá trịintdùng shared object), tổng cỡ 500–700 MB. Đơn giản, có TTL từng key. - B: 20.000 hash, mỗi hash 500 field ngắn vẫn là listpack (dưới ngưỡng 512), mỗi field chỉ vài byte. Tổng cỡ 50–80 MB, giảm gần 10 lần. Mất TTL theo từng user (trừ khi dùng
HEXPIREtừ 7.4), và hash không được vượt ngưỡng. - C: 10 triệu bit = 1,25 MB. Nhỏ nhất, đếm bằng
BITCOUNT, nhưng chỉ lưu đúng 1 bit, không TTL, vàuser_idphải dày đặc (id thưa lớn thì bitmap phình theo id lớn nhất).
Cách kiểm chứng: nạp 100.000 phần tử mỗi cách, so INFO memory (used_memory) trước và sau, rồi nhân lên. Đừng tin số ước lượng mà không đo, vì overhead phụ thuộc phiên bản và allocator (jemalloc).
Bài 2: chẩn đoán Redis latency nhảy lên mỗi giờ
Đề: p99 của Redis bình thường 1 ms, nhưng đúng mỗi đầu giờ nhảy lên 80 ms trong vài giây. Liệt kê giả thuyết và cách kiểm tra.
Lời giải Bài 2: bốn giả thuyết và cách kiểm tra
- Hàng loạt key hết hạn cùng lúc (job nạp cache đầu giờ với TTL tròn 1 giờ). Kiểm tra
INFO stats→expired_keystăng vọt đúng thời điểm; sửa bằng jitter TTL vàlazyfree-lazy-expire yes. - Snapshot RDB theo lịch (
save 3600 1):fork()của tiến trình vài chục GB tốn hàng chục ms chặn luồng chính. Kiểm traINFO persistence→latest_fork_usec; sửa bằng instance nhỏ hơn, tắt THP (transparent huge pages), hoặc chỉ snapshot trên replica. - Job cron chạy lệnh O(N) (báo cáo dùng
KEYS,SMEMBERSlớn). Kiểm traSLOWLOG GET 20; sửa bằngSCAN. - Rewrite AOF cũng
fork(), vàfsyncbị nghẽn disk làm luồng chính chờ. Kiểm traaof_rewrite_in_progress, log “Asynchronous AOF fsync is taking too long”.
Bật LATENCY MONITOR (CONFIG SET latency-monitor-threshold 10) rồi LATENCY DOCTOR để Redis tự gom nguyên nhân.
Ghi nhớ
- Giải thích được vì sao nút thắt của Redis là mạng và bộ nhớ, không phải CPU.
- Nói chính xác được cái gì đơn luồng (chạy lệnh) và cái gì không (io-threads, luồng bio,
fork()). - Biết vì sao một lệnh O(N) làm chậm mọi client, và dùng gì thay
KEYS *. - Giải thích được encoding listpack và vì sao vượt ngưỡng làm bộ nhớ tăng vọt.
- Mô tả được hai cách xoá key hết hạn và biết khi nào chọn
allkeys-*haynoeviction.
Câu hỏi phỏng vấn
Junior
Redis là gì và thường dùng vào việc gì?
Kho key-value nằm trong RAM, value có kiểu (string, list, hash, set, sorted set, stream…) với lệnh chạy trên server.
Dùng làm cache, lưu session, bộ đếm và rate limit, bảng xếp hạng, hàng đợi nhẹ, distributed lock. Có persistence và replication nhưng thường không dùng làm kho chính cho dữ liệu quan trọng.
Vì sao Redis đơn luồng mà vẫn nhanh?
Vì nút thắt là mạng và bộ nhớ chứ không phải CPU: dữ liệu ở RAM nên mỗi lệnh chỉ tốn vài trăm nano giây CPU.
- Một luồng nghĩa là không lock, không context switch, mỗi lệnh tự nguyên tử.
- I/O multiplexing (
epoll) cho một luồng phục vụ hàng chục nghìn kết nối. - Cấu trúc dữ liệu được tối ưu: listpack cho tập nhỏ, skiplist, hash table rehash dần.
TTL của key hoạt động thế nào? Key hết hạn có bị xoá ngay không?
Không xoá ngay: Redis ghi thời điểm hết hạn vào dict expires, rồi xoá thụ động khi đọc hoặc chủ động bằng vòng lấy mẫu.
Thụ động: lệnh chạm vào key thấy đã quá hạn thì xoá. Chủ động: vòng chạy 10 lần/giây lấy mẫu key có TTL, xoá key hết hạn, lặp lại nếu hơn 25% mẫu đã hết hạn. Người đọc không bao giờ thấy key quá hạn, nhưng bộ nhớ có thể chưa được giải phóng ngay.
Mid
Redis 6 trở lên còn đơn luồng không?
Thực thi lệnh vẫn đơn luồng; chỉ I/O socket, việc nền và persistence chạy chỗ khác.
Từ trước bản 6 đã có luồng nền cho đóng file, fsync và giải phóng bộ nhớ (lazyfree). Bản 6 thêm io-threads tuỳ chọn (mặc định tắt) để đọc/parse request và ghi reply song song. Persistence dùng tiến trình con qua fork(), không phải luồng. Muốn nhiều core chạy lệnh thì chạy nhiều instance hoặc Cluster.
Encoding của một hash trong Redis là gì, và vì sao quan trọng?
Hash nhỏ (mặc định ≤ 512 field ở 7.4, mỗi value ≤ 64 byte) lưu dạng listpack; vượt ngưỡng thì thành hashtable và tốn bộ nhớ gấp 5–6 lần.
listpack là mảng byte liên tục, tra tuyến tính nhưng rất gọn. Mình đo được 5 KB → 28 KB khi thêm field thứ 513, và hash không tự quay lại listpack. Biết điều này để gom key nhỏ vào hash tiết kiệm bộ nhớ và tránh nhét value dài vào hash.
Vì sao KEYS * bị cấm trên production? Thay bằng gì?
Vì KEYS duyệt cả keyspace O(N) trên luồng chạy lệnh duy nhất, có thể chặn Redis hàng giây. Thay bằng SCAN.
SCAN với MATCH và COUNT duyệt theo con trỏ, mỗi lần một ít; chấp nhận có thể thấy trùng hoặc bỏ lỡ key thay đổi trong lúc duyệt. Tốt hơn nữa là thiết kế để không phải tìm key theo pattern (giữ index trong một set).
Khi Redis đầy bộ nhớ thì chuyện gì xảy ra?
Tuỳ maxmemory-policy; mặc định noeviction từ chối lệnh ghi với lỗi OOM, đọc vẫn chạy.
Với allkeys-lru/lfu, Redis bỏ key theo LRU/LFU xấp xỉ (lấy mẫu); với volatile-* chỉ bỏ key có TTL. Cache nên dùng allkeys-*; instance giữ dữ liệu không được mất (khoá, hàng đợi) nên noeviction và tách riêng.
Senior
Thiết kế để Redis giữ latency p99 thấp ổn định. Bạn chú ý những gì?
Không để gì chặn luồng chạy lệnh: không lệnh O(N), không big key, không hết hạn đồng loạt, fork() nhanh.
- Dùng SCAN, giới hạn kích thước collection, kiểm soát bằng ACL; dùng UNLINK/lazyfree cho key to.
- Rải TTL; instance vừa phải để
fork()nhanh, tắt THP, chừa RAM cho copy-on-write; AOFeverysectrên disk riêng. - Pipeline/MGET thay vì nhiều round-trip; client timeout ngắn và pool hợp lý.
- Theo dõi SLOWLOG, LATENCY DOCTOR,
latest_fork_usec,expired_keys,evicted_keys,mem_fragmentation_ratio.
Tại sao sorted set dùng skiplist thay vì cây cân bằng?
Vì skiplist đơn giản hơn mà độ phức tạp tương đương (O(log N) kỳ vọng), range scan tự nhiên và tính rank dễ.
Insert/delete chỉ đổi con trỏ cục bộ, range scan là đi tiếp ở tầng dưới, thêm “span” ở mỗi liên kết là tính được rank O(log N). Sorted set dùng kèm một dict để ZSCORE O(1). Tập nhỏ (≤ 128 phần tử) dùng listpack cho gọn.
Một replica đọc thấy key đã hết hạn chưa? Bộ nhớ trên replica được giải phóng khi nào?
Không thấy: từ Redis 3.2 replica trả nil cho key đã quá hạn. Nhưng bộ nhớ chỉ được giải phóng khi master gửi DEL.
Replica không tự xoá; nó chờ master sinh DEL (khi master xoá thụ động hoặc chủ động) qua stream replication. Vì vậy bộ nhớ replica có thể cao hơn master một chút, và nếu đồng hồ giữa các máy lệch nhiều thì kết quả có thể khác nhau.
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 |
|---|---|---|---|
| in-memory | /ɪn ˈmeməri/ | nằm trong RAM | “Redis is an in-memory store, so the bottleneck is usually the network, not the CPU.” |
| event loop | /ɪˈvent luːp/ | vòng lặp xử lý sự kiện | “A single event loop handles tens of thousands of connections.” |
| I/O multiplexing | /ˌaɪ ˈəʊ ˈmʌltɪpleksɪŋ/ | một luồng theo dõi nhiều socket | “With epoll, one thread only touches the sockets that are ready.” |
| atomic | /əˈtɒmɪk/ | nguyên tử, không bị xen ngang | “Every Redis command is atomic because commands run on one thread.” |
| encoding | /ɪnˈkəʊdɪŋ/ | cách lưu bên dưới của một kiểu | “A small hash uses the listpack encoding and converts to a hash table past the threshold.” |
| incremental rehashing | /ˌɪŋkrəˈmentl riːˈhæʃɪŋ/ | rehash dần dần | “Incremental rehashing avoids a long pause when the dictionary grows.” |
| skip list | /skɪp lɪst/ | danh sách nhiều tầng | “Sorted sets combine a skip list for ranges with a hash table for lookups.” |
| lazy expiration | /ˈleɪzi ˌekspəˈreɪʃn/ | xoá khi bị truy cập | “Lazy expiration alone would leave keys nobody reads.” |
| active expiration | /ˈæktɪv ˌekspəˈreɪʃn/ | xoá định kỳ chủ động | “The active expire cycle samples keys with a TTL ten times per second.” |
| eviction policy | /ɪˈvɪkʃn ˈpɒləsi/ | chính sách bỏ key khi đầy | “For a pure cache I’d pick allkeys-lru or allkeys-lfu.” |
| copy-on-write | /ˈkɒpi ɒn raɪt/ | chép trang bộ nhớ khi bị ghi | “Leave headroom for copy-on-write when the server forks for a snapshot.” |
| tail latency | /teɪl ˈleɪtənsi/ | độ trễ ở phân vị cao (p99) | “One slow command shows up as tail latency for every client.” |
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.