Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

System DesignSenior25 phút đọc

Review code distributed lock bằng Redis: 6 lỗi thường gặp

Ôn 15 thẻ
Trong bài này

Cụm bài Cache: 1. Cache-aside và invalidation · 2. Sự cố cache: avalanche, breakdown, penetration · 3. Review code distributed lock bằng Redis

Distributed lock bằng Redis trông đơn giản (SET key value NX là xong) nhưng nhiều bug, vì bug chỉ lộ ra khi có GC pause, failover, hay hai request tranh nhau đúng một mili giây. Bài này review code mẫu của khoá học (dự án đặt vé máy bay), chạy thử sáu lỗi trên Redis 7 rồi viết lại. Nên đọc trước: Transaction, isolation level và locking (lock của database, SELECT ... FOR UPDATE, advisory lock), vì câu hỏi cuối bài là “có cần Redis lock không”.

Sơ đồ tóm tắt:

flowchart TD
  A{"Lock cho việc gì?"} -->|"Dòng DB"| B["Điều kiện, version, FOR UPDATE"]
  A -->|"Việc ngoài DB"| C["SET token NX PX ttl"]
  C --> D["Nhiều khoá: theo thứ tự"]
  D --> E["Làm việc trong lease"]
  E --> F["Unlock: Lua so token"]
  E -.->|"GC pause, failover"| G["Hai người cùng giữ"]
  G --> H["Fencing token ở tài nguyên"]

1. Hai lý do để cần một lock

Ý chính: câu hỏi đầu tiên khi review là lock này để tiết kiệm hay để đúng đắn. Hai loại cần mức bảo đảm rất khác nhau (cách chia của Martin Kleppmann).

  • Hiệu quả: tránh làm một việc hai lần (hai pod cùng gửi email báo cáo). Lock thỉnh thoảng hỏng chỉ tốn thêm tài nguyên; một Redis node với SET NX PX là đủ.
  • Đúng đắn: hai bên cùng chạy là sai dữ liệu (bán một ghế cho hai người). Redis lock một mình không đủ: cần fencing token ở tài nguyên, hoặc dùng database làm cơ chế khoá (mục 6).

2. Primitive đúng

Ý chính: lấy khoá bằng một lệnh nguyên tử có token ngẫu nhiên và TTL; mở khoá và gia hạn đều phải so token trong script Lua.

SET lock:order:42 <token ngẫu nhiên> NX PX 30000
  • NX: chỉ set nếu chưa có, nên chỉ một client lấy được.
  • PX 30000: tự hết hạn sau 30 giây, để client chết giữa chừng không giữ khoá mãi.
  • Token ngẫu nhiên (UUID) cho mỗi lần lấy: khi mở, client chứng minh khoá đang là của mình.

Mở khoá phải so token và xoá trong một bước. Lua làm được vì Redis chạy cả script mà không xen lệnh khác:

if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) end
return 0

Gia hạn (việc chạy lâu hơn TTL) cũng so token: if GET == token then PEXPIRE.

3. Code được review

Ý chính: RedisService khoá bằng giá trị hằng 1 và mở bằng delete(key); DistributedLockService lấy nhiều khoá song song và unlock bất đồng bộ. Mỗi chỗ đó là một lỗi ở mục 4.

  • lock(key, ttl) gọi setIfAbsent(key, 1, ttl); unlock(key) là delete(key).
  • lockWithRetry thử lại với backoff lũy thừa (50 ms × 2^n) đến khi tổng thời gian chờ vượt timeout.
  • DistributedLockService đọc TTL/timeout từ cấu hình, nhân 1000 trong @PostConstruct.
  • lockWithRetry(List<String>) lấy các khoá song song trên thread pool, thất bại thì unlock tất cả; unlock chạy bất đồng bộ.
Trích đoạn code mẫu và cách dựng lại

Vài dòng đáng chú ý (trích tối thiểu):

return redisTemplate.opsForValue().setIfAbsent(key, DefaultValue.NUMBER_ONE, ttlMillisecond, TimeUnit.MILLISECONDS);
...
public void unlock(String key) { redisTemplate.delete(generateKey(key)); }
...
lockTTL = lockTTLInSecond * 1000;                       // @PostConstruct
return redisService.lock(lockKey, lockTTL * 1000);      // lock()
...
if (!lockResult) { unlock(lockResultList.keySet()); }   // lockWithRetry(List)
CompletableFuture.runAsync(() -> redisService.unlock(lockKey), executor);

Mình dựng lại từng hành vi bằng Jedis trên Redis 7 để chạy các kịch bản ở mục 4.

4. Sáu lỗi

Ý chính: năm lỗi đầu là lỗi code, sửa được: khoá không có chủ, TTL sai đơn vị, lấy nhiều khoá không thứ tự, unlock bất đồng bộ, vòng retry hỏng. Lỗi thứ sáu nằm ở bản chất lease, code client không chữa được.

Lỗi 1: giá trị khoá hằng số và DEL mù

Mọi client set cùng giá trị 1, và unlock xoá mà không hỏi khoá của ai. Kịch bản:

  1. A lấy khoá TTL 200 ms, rồi bị pause 300 ms (GC, query chậm).
  2. Khoá hết hạn, B lấy khoá.
  3. A tỉnh dậy, chạy finally { unlock }, xoá khoá của B.
  4. C lấy khoá ngay sau đó: B và C cùng ở trong vùng găng (đoạn code chỉ được một bên chạy tại một thời điểm).
A lock(200ms): true
B lock: true
C lock while B still works: true  <- B and C both inside

Cùng kịch bản với token + Lua:

A unlock with stale token: false
C lock while B works: false
B extend: 1, pttl=30000
B unlock: true

Trong lockWithRetry(List) còn tệ hơn. Lấy thiếu một khoá thì code unlock toàn bộ key trong map kết quả, kể cả key mình không lấy được, tức là xoá khoá người khác đang giữ:

B results: {lock:seat:1=true, lock:seat:2=false}
seat 2 still locked by A? false  <- A's lock deleted by B

Lỗi 2: TTL bị nhân 1000 hai lần, và cấu hình không khớp

Biến lockTTLInSecond được nhân 1000 trong init() để ra mili giây, rồi lock() nhân 1000 lần nữa. Cấu hình đặt ttl: 300000 (nhiều khả năng ý là 300.000 ms = 5 phút, dù tên biến nói là giây):

intended 300000 ms = 5.0 min; actual 300000000000 ms = 9.5 years

Đường lockWithRetry chỉ nhân một lần, nên cùng cấu hình mà TTL là 83 giờ. Pod chết khi đang giữ khoá thì tài nguyên bị khoá 83 giờ (hoặc 9,5 năm).

Lỗi cấu hình phụ: placeholder timeout không tồn tại

Code còn đọc ${app.transaction.lock.timeout} nhưng file cấu hình chỉ có ttl và wait. Placeholder không có giá trị mặc định thì Spring không khởi động (Could not resolve placeholder). Một nhánh khác của repo vá bằng giá trị mặc định: lỗi bị che chứ không được sửa.

Lỗi 3: lấy nhiều khoá song song, không theo thứ tự

Lấy khoá nhiều ghế bằng các CompletableFuture song song nghĩa là không có thứ tự. X cần {1, 2}, Y cần {2, 1}: X giữ 1, Y giữ 2, cả hai retry cùng lịch backoff (không jitter), cùng thất bại, cùng nhả, lặp lại. Đó là livelock: giống deadlock, nhưng cả hai vẫn chạy và không ai tiến lên. Cộng lỗi 1, mỗi lần nhả còn xoá khoá của bên kia.

Sửa theo một trong hai cách:

  • Thứ tự toàn cục: sắp xếp key rồi lấy tuần tự; thất bại thì nhả khoá đã lấy theo thứ tự ngược. Hai request có tập giao nhau luôn tranh khoá nhỏ nhất trước, nên không giữ chéo được.
  • Tất cả hoặc không bằng một script Lua: kiểm tra mọi key chưa tồn tại rồi set tất cả. Trên Redis Cluster, key trong một script phải cùng slot, nên dùng hash tag: {flight:9}:seat:1, {flight:9}:seat:2.
A locks {seat:2}: 1
B locks {seat:1, seat:2}: 0
seat:1 left behind by B? false
B unlock-all removes only its own: 0

Lỗi 4: unlock bất đồng bộ trên thread pool không giới hạn

unlock đẩy DEL lên Executors.newCachedThreadPool() rồi trả về ngay. Hệ quả:

  • Method trả về khi khoá vẫn còn; request tiếp theo của chính user đó có thể bị từ chối.
  • Unlock lỗi thì không ai biết: exception nằm trong một future không ai đọc.
  • Pod tắt có thể mất tác vụ unlock đang chờ, khoá nằm đến hết TTL (theo lỗi 2 là 9,5 năm).
  • newCachedThreadPool không giới hạn số thread; Redis chậm thì mỗi lần lấy/nhả thêm một thread, service chết vì hết thread.

Unlock là một round-trip dưới 1 ms: gọi đồng bộ trong finally (hoặc close() của try-with-resources). Log khi script trả 0: khoá đã hết hạn trước khi nhả, tức vùng găng có thể đã chồng lấn.

Lỗi 5: vòng retry

do {
    if (setNx(key, keyTTL)) return true;
    wait = INIT_INTERVAL * (long) Math.pow(MULTIPLIER, retries);
    Thread.sleep(wait);
    retries++;
    totalWait += wait;
} while (totalWait <= retryTimeout);
  • Ngủ rồi không thử lại: lần ngủ làm totalWait vượt timeout là lần ngủ cuối, vòng lặp thoát mà không gọi setNx nữa. Với timeout 10 giây, lần ngủ cuối 6,4 giây là vô ích.
  • Không jitter (độ lệch ngẫu nhiên): client cùng bắt đầu sẽ retry cùng lúc, tranh nhau theo đợt.
  • Không giới hạn mỗi lần chờ: 50 ms × 2^n tăng đến hàng chục giây.
  • totalWait bỏ qua thời gian round-trip; nên dùng deadline theo System.nanoTime().
  • catch (Exception e) { return false; }: xem pitfall dưới.

Lỗi 6: lease hết hạn, failover, và vì sao cần fencing token

Sửa hết năm lỗi trên, Redis lock vẫn là một lease: nó tự hết hạn. Hai cách nó hỏng mà code không làm gì được:

  1. Client bị pause lâu hơn TTL (GC stop-the-world, VM bị treo, query DB chậm). Client không biết mình đã mất khoá, vẫn ghi tiếp.
  2. Failover: replication của Redis bất đồng bộ. A lấy khoá trên primary, primary chết trước khi lệnh chép sang replica, replica lên primary không có khoá, B lấy được.

Cách chữa thật là fencing token: mỗi lần lấy khoá nhận một số tăng dần (INCR), gửi kèm mỗi lần ghi, và tài nguyên từ chối số nhỏ hơn số lớn nhất đã thấy:

UPDATE seat SET holder = :holder, fence = :token
WHERE id = :id AND fence < :token;      -- 0 dòng nghĩa là token đã cũ: dừng lại
B writes with token 2: true
A (woke up) writes with token 1: false
stored value: B

Redlock (lấy khoá trên đa số N node Redis độc lập) chữa được trường hợp 2 nếu các giả định về đồng hồ và độ trễ đúng. Nhưng Kleppmann chỉ ra nó không cứu trường hợp 1: không lock dựa trên thời gian nào ngăn được client đã bị pause.

Trường hợp 1 có số đo ở Optimistic hay pessimistic locking: Redis lock TTL 5 ms bọc 10 ms xử lý bán ra 311 vé cho chuyến bay 100 ghế; cùng lock đó nhưng kiểm tra cột version khi ghi (đóng vai fencing token) thì bán đúng 100.

Lịch sử lệnh: từ SETNX + EXPIRE đến SET NX PX

Phân tích trên là để hiểu lỗi; trong PR thật, chúng phải thành comment mà tác giả đọc là biết sửa gì. Mục “Review mẫu 2” của bài Code review: hai buổi review mẫu viết lại chính các lỗi này thành comment có nhãn (TODO, QUESTION, FYI), mỗi comment kèm hậu quả cụ thể (“khoá 30 giây thành 8 tiếng”) và cách sửa.

5. Viết lại

Ý chính: API trả Lease là AutoCloseable, dùng với try-with-resources nên không thể quên nhả. Bên trong: token ngẫu nhiên, unlock/gia hạn bằng Lua so token, retry theo deadline có jitter, “bận” là Optional.empty() còn Redis lỗi thì ném exception.

Cách dùng:

try (var lease = lock.tryAcquire("order:" + orderId, Duration.ofSeconds(30), Duration.ofSeconds(2))
        .orElseThrow(() -> new OrderBusyException(orderId))) {      // map thành 409
    // vùng găng: ngắn, không gọi ra ngoài mà không có timeout
}

Dùng Redisson thì không cần tự viết lớp này; nhưng vẫn phải tự lo fencing token cho lock cần đúng đắn.

Lớp RedisLock đầy đủ
@Component
public class RedisLock {
    private static final Logger log = LoggerFactory.getLogger(RedisLock.class);
    private static final RedisScript<Long> UNLOCK = new DefaultRedisScript<>("""
        if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) end
        return 0
        """, Long.class);
    private static final RedisScript<Long> EXTEND = new DefaultRedisScript<>("""
        if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('PEXPIRE', KEYS[1], ARGV[2]) end
        return 0
        """, Long.class);

    private final StringRedisTemplate redis;

    public RedisLock(StringRedisTemplate redis) { this.redis = redis; }

    /** Rỗng nghĩa là "bận"; exception nghĩa là "Redis không dùng được". */
    public Optional<Lease> tryAcquire(String name, Duration ttl, Duration maxWait) throws InterruptedException {
        String key = "lock:" + name;
        String token = UUID.randomUUID().toString();
        long deadline = System.nanoTime() + maxWait.toNanos();
        long backoffMs = 20;
        while (true) {
            if (Boolean.TRUE.equals(redis.opsForValue().setIfAbsent(key, token, ttl))) {
                return Optional.of(new Lease(key, token));
            }
            long remainingMs = (deadline - System.nanoTime()) / 1_000_000;
            if (remainingMs <= 0) return Optional.empty();
            long jittered = ThreadLocalRandom.current().nextLong(backoffMs / 2, backoffMs + 1);
            Thread.sleep(Math.min(jittered, remainingMs));      // InterruptedException đi lên
            backoffMs = Math.min(backoffMs * 2, 500);
        }
    }

    /** Nhiều tài nguyên: thứ tự toàn cục, tất cả hoặc không, chỉ nhả thứ mình giữ. */
    public Optional<List<Lease>> tryAcquireAll(List<String> names, Duration ttl, Duration maxWait) throws InterruptedException {
        List<Lease> held = new ArrayList<>();
        for (String name : names.stream().distinct().sorted().toList()) {
            Optional<Lease> lease = tryAcquire(name, ttl, maxWait);
            if (lease.isEmpty()) {
                held.reversed().forEach(Lease::close);
                return Optional.empty();
            }
            held.add(lease.get());
        }
        return Optional.of(held);
    }

    public final class Lease implements AutoCloseable {
        private final String key;
        private final String token;

        private Lease(String key, String token) { this.key = key; this.token = token; }

        public boolean extend(Duration ttl) {
            return Long.valueOf(1).equals(redis.execute(EXTEND, List.of(key), token, String.valueOf(ttl.toMillis())));
        }

        @Override
        public void close() {
            Long deleted = redis.execute(UNLOCK, List.of(key), token);
            if (deleted == null || deleted == 0) {
                log.warn("lock {} had expired before release: another holder may have run concurrently", key);
            }
        }
    }
}

List.reversed() là của Java 21 (Sequenced Collections).

6. Khi nào không cần Redis lock

Ý chính: phần lớn “cần distributed lock” thực ra là “hai request không được ghi đè nhau trên cùng một dòng DB”. Khi đó database khoá tốt hơn Redis.

Khoá của DB nằm trong transaction, tự nhả khi commit/rollback hoặc khi kết nối chết, và không có chuyện lease hết hạn giữa chừng.

Bài tập

Bài 1: local cache danh sách sân bay (bài tập về nhà của buổi caching)

Đề (diễn giải): cài một local cache cho danh sách sân bay (mã, tên) theo kiểu read-aside, có TTL. Được dùng thư viện; không bắt buộc có DB, có thể hardcode danh sách.

Lời giải Bài 1: Caffeine, Spring @Cacheable và review lời giải mẫu

Lời giải 1: Caffeine thuần, để thấy rõ hành vi.

record Airport(String code, String name) {}

Cache<String, List<Airport>> cache = Caffeine.newBuilder()
    .expireAfterWrite(Duration.ofSeconds(1))
    .maximumSize(1_000)
    .recordStats()
    .build();

List<Airport> airports() {
    return cache.get("all", k -> loadFromDb());   // read-aside + single-flight theo key
}

Chạy thử (loader giả lập query 200 ms, TTL 1 giây):

miss -> load from DB
hit (3 airports)
hit (3 airports)
after TTL: expired, next read goes to DB
naive check-then-put, 100 threads: DB calls = 100
cache.get(key, loader), 100 threads: DB calls = 1
cached list after a caller mutated it: [HAN, SGN, XXX]

Dòng cuối là cái bẫy: cache giữ tham chiếu, caller nào “lọc tạm” danh sách nhận được là sửa luôn bản trong cache cho mọi request khác. Lưu List.copyOf(...) (bất biến).

Lời giải 2: Spring Boot 3 với @Cacheable.

@Configuration
@EnableCaching
class LocalCacheConfig {
    @Bean
    CacheManager localCacheManager(@Value("${app.cache.airports.ttl:10m}") Duration ttl) {
        CaffeineCacheManager manager = new CaffeineCacheManager("airports");
        manager.setCaffeine(Caffeine.newBuilder()
            .expireAfterWrite(ttl)
            .maximumSize(10_000)
            .recordStats());                     // lộ ra qua Actuator: cache.gets{result=hit|miss}
        manager.setAllowNullValues(false);
        return manager;
    }
}

@Service
class AirportService {
    private final AirportRepository repository;

    AirportService(AirportRepository repository) { this.repository = repository; }

    @Cacheable(cacheNames = "airports", key = "'all'", sync = true)
    public List<Airport> findAll() {
        log.info("airports: cache miss, loading from DB");
        return List.copyOf(repository.findAll());
    }
}

Với logging.level.org.springframework.cache=TRACE, lần đầu log “No cache entry for key ‘all’” kèm câu SQL, lần sau “Cache entry for key ‘all’ found”.

Review lời giải mẫu của khoá học. Lời giải mẫu đặt @Cacheable(key = "#root.methodName", cacheNames = "localCache", cacheManager = "localCacheManager") trên findAll() của repository, Caffeine expireAfterWrite(20s), và CaffeineCacheManager đánh dấu @Primary. Đúng cho bài tập, nhưng đưa lên production thì:

  • Key va chạm: một cache chung localCache với key là tên method. Repository khác có findAll() dùng cache này sẽ nhận danh sách sân bay khi hỏi danh sách hãng bay, rồi ClassCastException. Mỗi loại dữ liệu một cache name, key nói rõ nội dung.
  • Không sync = true: hết hạn mỗi 20 giây là một đợt stampede nhỏ (100 request đồng thời = 100 query, như số đo ở trên).
  • Không maximumSize: cache không giới hạn; key theo tham số thì bộ nhớ tăng mãi.
  • Mỗi pod một bản: N pod hết hạn lệch nhau, có lúc pod A thấy sân bay mới còn pod B chưa. Dữ liệu đổi hiếm thì chấp nhận được; nếu không, dùng Redis hoặc broadcast invalidation (Redis pub/sub, client-side caching).
  • Trả list có thể sửa từ cache (cái bẫy ở dòng cuối kết quả chạy).
  • @Primary cho local cache manager: mọi @Cacheable không chỉ định cacheManager âm thầm thành local cache, kể cả thứ lẽ ra nằm ở Redis.

Bài 2: chọn cơ chế khoá cho đặt ghế

Đề (diễn giải): API giữ ghế cho chuyến bay, mỗi request giữ 1–4 ghế, ghế lưu ở bảng seat(flight_id, seat_no, holder, held_until) trên PostgreSQL. Có cần Redis lock không?

Lời giải Bài 2: để PostgreSQL tự khoá

Không. Giữ ghế là ghi vào chính các dòng trong DB, nên để DB tự khoá:

BEGIN;
SELECT seat_no FROM seat
WHERE flight_id = :f AND seat_no = ANY(:seats)
  AND (holder IS NULL OR held_until < now())
ORDER BY seat_no            -- thứ tự cố định: không deadlock giữa hai request giao nhau
FOR UPDATE;
-- đủ số ghế thì UPDATE ... SET holder = :user, held_until = now() + interval '10 minutes'; ngược lại ROLLBACK
COMMIT;

Với một ghế, một câu UPDATE ... WHERE holder IS NULL rồi kiểm tra số dòng bị ảnh hưởng là đủ. Redis lock chỉ cần nếu bước giữ ghế còn gọi hệ thống ngoài không có transaction chung; khi đó kèm fencing token lưu trong bảng seat.

Bài 3: 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 đến cùng lúc, cùng muốn đặt ghế A34_S012C trên chuyến FA634. Dùng distributed lock bằng Redis để tại một thời điểm chỉ một request được xử lý. Không cần cài database hay logic đặt chỗ.

Lời giải Bài 3: Jedis, token và kiểm tra lại sau khi có khoá

Lời giải dùng Jedis 5.2 (không cần Spring), chạy với Redis 7.4 và JDK 21. “Database” là một ConcurrentHashMap ghế → người giữ, đủ để thấy ai thắng:

enum Result { BOOKED, SEAT_BUSY, SEAT_TAKEN }

static final String UNLOCK = """
    if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) end
    return 0
    """;
static final Map<String, String> seatOwner = new ConcurrentHashMap<>();   // "DB" giả lập

static Result book(JedisPooled redis, String flight, String seat, String user) throws InterruptedException {
    String key = "lock:seat:" + flight + ":" + seat;                     // khoá đúng tài nguyên
    String token = UUID.randomUUID().toString();                          // mỗi lần lấy một token
    String ok = redis.set(key, token, SetParams.setParams().nx().px(10_000));
    if (!"OK".equals(ok)) return Result.SEAT_BUSY;                        // người khác đang giữ: trả 409
    try {
        if (seatOwner.containsKey(seat)) return Result.SEAT_TAKEN;         // kiểm tra lại SAU khi có khoá
        Thread.sleep(100);                                                 // giả lập ghi DB, gọi API
        seatOwner.put(seat, user);
        return Result.BOOKED;
    } finally {
        redis.eval(UNLOCK, List.of(key), List.of(token));                  // chỉ xoá nếu vẫn là khoá của mình
    }
}

Hai thread chờ một CountDownLatch rồi cùng gọi book(redis, "FA634", "A34_S012C", ...). Kết quả:

alice -> SEAT_BUSY
bob -> BOOKED
owner = bob
lock left = false
rounds with booked != 1: 0

Dòng cuối là vòng kiểm tra mạnh hơn: 200 vòng, mỗi vòng 8 thread tranh một ghế mới, vòng nào cũng đúng một request BOOKED. Khoá được nhả sạch sau mỗi lần (lock left = false).

Ba điểm làm lời giải đúng:

  • Token ngẫu nhiên và mở khoá bằng script so token (mục lỗi 1).
  • Kiểm tra trạng thái ghế sau khi có khoá: request thua có thể lấy khoá ngay sau khi người thắng nhả, lúc đó phải trả SEAT_TAKEN chứ không đặt đè.
  • Trả “bận” (409, client thử lại) thay vì chờ vô hạn.

Trong hệ thống thật, như bài 2 đã nói, câu lệnh có điều kiện trong database vẫn là hàng rào cuối cùng; khoá Redis chỉ giảm tranh chấp trước khi chạm DB.

Các cấu trúc dữ liệu và chế độ triển khai Redis khác có ở cụm bài Redis.

Ghi nhớ

  • Giải thích được vì sao unlock phải so token trong Lua, và kịch bản GC pause làm DEL mù xoá khoá người khác.
  • Biết cách lấy nhiều khoá mà không livelock: thứ tự đã sắp xếp hoặc Lua tất-cả-hoặc-không với hash tag.
  • Chỉ ra được năm lỗi code trong vòng retry và unlock bất đồng bộ, và cách sửa từng lỗi.
  • Giải thích được vì sao Redis lock là lease, Redlock không cứu được client bị pause, và fencing token chữa thế nào.
  • Biết khi nào dùng lock của database thay vì Redis.

Câu hỏi phỏng vấn

Mid

Cài distributed lock bằng Redis thế nào cho đúng ở mức cơ bản?

Lấy bằng SET lock:x <token ngẫu nhiên> NX PX <ttl>, mở bằng script Lua so token rồi mới DEL.

Lệnh lấy nguyên tử, chỉ một người thắng, tự hết hạn nếu client chết. So token khi mở để không xoá khoá của người khác; gia hạn cũng so token. Không dùng SETNX rồi EXPIRE riêng.

Lấy nhiều khoá cùng lúc thì cần chú ý gì?

Thứ tự và tính tất-cả-hoặc-không.

Lấy theo thứ tự sắp xếp cố định để hai request có tập giao nhau không giữ chéo nhau (deadlock, hoặc livelock khi có retry); thất bại thì chỉ nhả khoá mình đã lấy. Hoặc dùng một script Lua kiểm tra rồi set tất cả, với hash tag để các key cùng slot trên Cluster.

Senior

Redis lock có an toàn khi Redis failover không? Redlock giải quyết được gì?

Không an toàn. Redlock chịu được một số node chết, nhưng không chống được client bị pause lâu hơn TTL.

Replication bất đồng bộ nên primary có thể chết trước khi khoá được chép sang replica; replica lên primary không có khoá, client thứ hai lấy được. Redlock lấy khoá trên đa số N node độc lập, nhưng dựa vào giả định về đồng hồ và độ trễ. Lock cần đúng đắn thì phải có fencing token được tài nguyên kiểm tra, hoặc dùng cơ chế khoá của chính database.

Fencing token là gì?

Một số tăng dần cấp kèm mỗi lần lấy khoá, và tài nguyên từ chối mọi lần ghi mang số cũ hơn số lớn nhất đã thấy.

Nguồn số: INCR trên Redis, hoặc version của ZooKeeper/etcd. Ví dụ UPDATE ... SET fence = :t WHERE id = :id AND fence < :t. Client cũ tỉnh dậy sau khi mất khoá sẽ bị từ chối. Nó biến lock từ “hiệu quả” thành “đúng đắn”, với điều kiện tài nguyên kiểm tra được token.

Việc trong vùng găng có thể chạy lâu hơn TTL. Bạn xử lý thế nào?

Trước hết làm vùng găng ngắn lại; không được thì gia hạn bằng watchdog và kèm fencing token.

  • Đưa lời gọi ngoài ra khỏi vùng găng, đặt timeout cho mọi I/O bên trong.
  • Gia hạn định kỳ bằng script so token (watchdog như Redisson, mỗi 1/3 TTL), dừng việc nếu gia hạn thất bại.
  • Fencing token vì watchdog không cứu được khi cả JVM bị pause.
  • Khi nhả, log nếu script trả 0 (khoá đã hết hạn): dấu hiệu vùng găng có thể đã chồng lấn.
Khi nào bạn dùng lock của database thay vì Redis?

Khi tài nguyên cần bảo vệ là dòng trong DB; Redis lock dành cho việc nằm ngoài transaction DB, như gọi API ngoài hay job nhiều pod.

Thứ tự ưu tiên: câu lệnh có điều kiện hoặc unique constraint (không cần lock), optimistic lock bằng version, SELECT ... FOR UPDATE có ORDER BY, advisory lock như pg_advisory_xact_lock. Khoá của DB nằm trong transaction, tự nhả khi commit/rollback hay khi kết nối chết, không có lease hết hạn giữa chừng.

Review một hàm lấy khoá có catch (Exception e) { return false; }. Bạn comment gì?

Hàm trả cùng một kết quả cho “khoá bận” và “Redis chết”, và nuốt InterruptedException.

Caller không thể trả đúng 409 hay 503, không mở circuit breaker hay chuyển cơ chế khác được. Mất cờ interrupt nên thread không dừng khi shutdown. Đề nghị: Optional.empty() cho bận, để exception hạ tầng đi lên, throws InterruptedException, và metric riêng cho từng trường hợp.

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
distributed lock /dɪˈstrɪbjuːtɪd lɒk/ khoá dùng chung giữa nhiều process “We only use a distributed lock for work that isn’t inside a database transaction.”
lease /liːs/ khoá có thời hạn, tự hết “A Redis lock is really a lease: it expires whether you’re done or not.”
critical section /ˈkrɪtɪkl ˈsekʃn/ vùng găng “Keep the critical section short and give every call inside it a timeout.”
fencing token /ˈfensɪŋ ˈtəʊkən/ số tăng dần để tài nguyên từ chối người giữ cũ “The database rejects writes carrying an older fencing token.”
failover /ˈfeɪləʊvə/ chuyển sang node dự phòng “With asynchronous replication, a failover can lose a lock that was just acquired.”
livelock /ˈlaɪvlɒk/ các bên vẫn chạy nhưng không ai tiến lên “Acquiring keys in parallel without ordering led to a livelock under contention.”
backoff /ˈbækɒf/ chờ tăng dần trước khi thử lại “Retries use capped exponential backoff with jitter.”
hash tag /hæʃ tæɡ/ phần {...} trong key quyết định slot trên Cluster “We use a hash tag so all seat keys of a flight land in the same slot.”
advisory lock /ədˈvaɪzəri lɒk/ khoá theo tên do DB quản lý “A Postgres advisory lock is released automatically at the end of the transaction.”
watchdog /ˈwɒtʃdɒɡ/ tiến trình tự gia hạn khoá “Redisson’s watchdog extends the lease while the holder is alive.”

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.