Dağıtık Kilit ve Fencing Token — Kilit Senin Sandığında

1
@Component
2
class InterestLock {
3

4
    private static final Duration LEASE = Duration.ofMinutes(5);
5
    private final StringRedisTemplate redis;
6

7
    InterestLock(StringRedisTemplate redis) {
8
        this.redis = redis;
9
    }
10

11
    /** A granted lock carries a token that only goes up, whoever holds it. */
12
    Optional<Long> tryAcquire(String job, String owner) {
13
        Boolean acquired = redis.opsForValue().setIfAbsent("lock:" + job, owner, LEASE);
14
        if (!Boolean.TRUE.equals(acquired)) {
15
            return Optional.empty();
16
        }
17
        return Optional.of(redis.opsForValue().increment("fence:" + job));
18
    }
19
}

1
@Component
2
class NightlyInterestJob {
3

4
    private final InterestLock lock;
5
    private final InterestLedger ledger;
6
    private final AccountQueries accounts;
7
    private final String owner = UUID.randomUUID().toString();
8

9
    NightlyInterestJob(InterestLock lock, InterestLedger ledger, AccountQueries accounts) {
10
        this.lock = lock;
11
        this.ledger = ledger;
12
        this.accounts = accounts;
13
    }
14

15
    @Scheduled(cron = "0 5 0 * * *")
16
    void run() {
17
        lock.tryAcquire("nightly-interest", owner).ifPresent(token -> {
18
            LocalDate day = LocalDate.now(ZoneId.of("Europe/Istanbul")).minusDays(1);
19
            for (AccountInterest due : accounts.interestDueFor(day)) {
20
                // The token travels with every write; the ledger decides, not this process.
21
                ledger.pay(due, day, token);
22
            }
23
        });
24
    }
25
}

1
@Repository
2
class InterestLedger {
3

4
    private final JdbcClient jdbc;
5

6
    InterestLedger(JdbcClient jdbc) {
7
        this.jdbc = jdbc;
8
    }
9

10
    @Transactional
11
    void pay(AccountInterest due, LocalDate day, long token) {
12
        // Fencing: only a token at least as new as the highest seen may write.
13
        int fenced = jdbc.sql("""
14
                UPDATE job_fence SET highest_token = :token
15
                WHERE job = 'nightly-interest' AND highest_token <= :token
16
                """).param("token", token).update();
17
        if (fenced == 0) {
18
            throw new StaleLockHolderException(token);   // a newer holder already wrote
19
        }
20
        jdbc.sql("""
21
                INSERT INTO interest_entry (account_id, business_day, amount, fence_token)
22
                VALUES (:account, :day, :amount, :token)
23
                """)
24
            .param("account", due.accountId()).param("day", day)
25
            .param("amount", due.amount()).param("token", token)
26
            .update();   // unique (account_id, business_day) is the last line of defence
27
    }
28
}

1
CREATE TABLE job_fence (
2
    job            VARCHAR(64) PRIMARY KEY,
3
    highest_token  BIGINT NOT NULL
4
);
5
INSERT INTO job_fence (job, highest_token) VALUES ('nightly-interest', 0);
6

7
ALTER TABLE interest_entry
8
    ADD CONSTRAINT uq_interest_once_per_day UNIQUE (account_id, business_day);