Distributed LockDistributed Lock

instance chạy cùng jobinstances running the same job

6

instance chạy cùng jobinstances running the same job

TTL của khoálock TTL

30s

TTL của khoálock TTL

lấy khoá trên Redisto acquire on Redis

< 2 ms

lấy khoá trên Redisto acquire on Redis

lần chi trả trùng cho một đơndouble payouts per order

0

lần chi trả trùng cho một đơndouble payouts per order

Scheduler kích hoạt job trên mọi instance. Instance nào SET NX thành công thì giữ khoá và nhận fencing token tăng dần; storage chỉ chấp nhận ghi có token lớn hơn token đã lưu. Bật “GC pause” để xem vì sao chỉ có TTL là chưa đủ.The scheduler fires the job on every instance. Whoever wins SET NX holds the lock and gets an increasing fencing token; the storage only accepts writes whose token is higher than the stored one. Turn on “GC pause” to see why a TTL alone is not enough.

1. 1

   Nhả nhầm khoá của người khácReleasing someone else's lock

   DEL thẳng sau khi TTL đã hết sẽ xoá khoá của instance khác. Lưu token ngẫu nhiên làm value và nhả bằng Lua: GET so token rồi mới DEL, trong một lệnh nguyên tử.A plain DEL after the TTL expired deletes another instance's lock. Store a random token as the value and release with Lua: compare it, then DEL, atomically.

   Semaphore
2. 2

   TTL quá ngắn hoặc quá dàiTTL too short or too long

   Quá ngắn: khoá hết hạn khi việc còn chạy. Quá dài: instance chết thì mọi người chờ đến hết TTL. Đặt TTL vừa phải và gia hạn định kỳ (watchdog của Redisson gia hạn mỗi lockWatchdogTimeout/3).Too short and it expires mid-work; too long and everyone waits after a crash. Keep it moderate and renew it (Redisson's watchdog renews every lockWatchdogTimeout/3).

   Cancellation / Context
3. 3

   GC pause và lệch đồng hồGC pauses and clock drift

   Một tiến trình có thể dừng lâu hơn TTL hoặc đồng hồ máy chạy lệch, nên không bao giờ chắc chắn mình còn giữ khoá. Storage phải kiểm tra fencing token tăng dần và từ chối token cũ.A process can stall past the TTL or run on a drifting clock, so it can never be sure it still holds the lock. The storage must check an increasing fencing token and refuse stale ones.

   Unit of Work
4. 4

   Có thật cần khoá phân tán khôngDo you need a distributed lock at all

   Một đơn chỉ chi trả một lần thì unique constraint hoặc optimistic locking (cột version) là đủ. Chia hàng việc cho nhiều worker thì dùng SELECT … FOR UPDATE SKIP LOCKED.One payout per order is a unique constraint or optimistic locking (a version column). Splitting a work queue across workers is SELECT … FOR UPDATE SKIP LOCKED.

   Unit of WorkRead-Write Lock
5. 5

   Redis failover làm mất khoáRedis failover loses the lock

   Replication bất đồng bộ: master chết trước khi key sang replica thì replica mới không có khoá. Redlock dùng đa số 5 node nhưng vẫn dựa vào thời gian; việc cần đúng tuyệt đối nên dùng etcd/ZooKeeper hoặc advisory lock của PostgreSQL.Replication is asynchronous: if the master dies before the key reaches a replica, the new master has no lock. Redlock uses a majority of 5 nodes but still relies on timing; for strict correctness use etcd/ZooKeeper or PostgreSQL advisory locks.

   Semaphore
6. 6

   Đọc nhiều, ghi ít trên cùng tài nguyênMany readers, few writers on one resource

   Khoá loại trừ cho cả việc đọc làm nghẽn không cần thiết. RReadWriteLock của Redisson cho nhiều người đọc cùng lúc và chỉ một người ghi.An exclusive lock for reads serialises traffic for nothing. Redisson's RReadWriteLock allows many readers at once and a single writer.

   Read-Write Lock

Java dùng Redisson tryLock không chờ, có leaseTime; Go tự viết SET NX + Lua compare-and-delete. Cả hai cấp fencing token và để storage từ chối token cũ.Java uses Redisson tryLock with no wait and a lease time; Go writes SET NX plus a Lua compare-and-delete. Both issue a fencing token and let the storage refuse stale ones.

@Slf4j
@Component
@RequiredArgsConstructor
public class PayoutJob {
    private final RedissonClient redisson;
    private final PayoutRepository payouts;

    @Scheduled(cron = "0 */5 * * * *")
    public void run() throws InterruptedException {
        RLock lock = redisson.getLock("lock:payout");
        if (!lock.tryLock(0, 30, TimeUnit.SECONDS)) {   // wait 0, lease 30s1
            log.info("payout job held by another instance, skipping");
            return;
        }
        try {
            long fence = redisson.getAtomicLong("fence:payout").incrementAndGet();2
            for (Payout p : payouts.findPending()) {
                if (payouts.markPaid(p.getOrderId(), fence) == 0) {
                    throw new StaleFenceException(fence); // a newer owner exists
                }
            }
        } finally {
            if (lock.isHeldByCurrentThread()) lock.unlock();3
        }
    }
}

public interface PayoutRepository extends JpaRepository<Payout, Long> {
    @Modifying
    @Transactional
    @Query("""
        UPDATE Payout p SET p.status = 'PAID', p.fence = :fence
        WHERE p.orderId = :orderId AND p.fence < :fence""")4
    int markPaid(String orderId, long fence);
}

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

var ErrStaleFence = errors.New("stale fencing token")

type Lock struct {
	rdb   *redis.Client
	key   string
	token string
	Fence int64
}

// Acquire returns nil, nil when another instance holds the lock.
func Acquire(ctx context.Context, rdb *redis.Client, key string, ttl time.Duration) (*Lock, error) {
	token := uuid.NewString()
	ok, err := rdb.SetNX(ctx, key, token, ttl).Result() // SET key token NX PX ttl2
	if err != nil || !ok {
		return nil, err
	}
	fence, err := rdb.Incr(ctx, "fence:"+key).Result()3
	if err != nil {
		_ = release.Run(ctx, rdb, []string{key}, token).Err()
		return nil, err
	}
	return &Lock{rdb: rdb, key: key, token: token, Fence: fence}, nil
}

func (l *Lock) Release(ctx context.Context) error {
	return release.Run(ctx, l.rdb, []string{l.key}, l.token).Err()
}

func MarkPaid(ctx context.Context, db *pgxpool.Pool, orderID string, fence int64) error {
	tag, err := db.Exec(ctx,
		"UPDATE payout SET status = 'PAID', fence = $2 WHERE order_id = $1 AND fence < $2",4
		orderID, fence)
	if err != nil {
		return err
	}
	if tag.RowsAffected() == 0 {
		return ErrStaleFence
	}
	return nil
}

Mỗi pattern mở bài học tương ứng trong menu Pattern.Each one opens its lesson in the Patterns menu.