Đến nội dung chính
Sổ ôn Backend

Tìm kiếm

System DesignSenior21 phút đọc

Lập lịch job phân tán: Quartz cluster, misfire và chia job lớn cho nhiều worker

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

Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.

Lập lịch job phân tán: Quartz cluster, misfire và chia job lớn cho nhiều worker

1Mô hình của Quartz

Quartz tách việc (Job, JobDetail) khỏi lịch (Trigger). Mỗi lần chạy là một instance Job mới, nên trạng thái nằm trong JobDataMap, không nằm trong field.

Thành phần Vai trò
Job Code nghiệp vụ, execute(...)
JobDetail Job + JobKey + JobDataMap
Trigger Lịch: cron, simple, múi giờ
JobStore RAM, hoặc bảng QRTZ_* cho cluster

2Hai annotation hay bị hỏi

@DisallowConcurrentExecution cấm chạy chồng theo JobKey, không theo class. Đã ghi lại JobDataMap thì gần như luôn cần cấm chạy chồng.

@DisallowConcurrentExecution  // theo JobKey
@PersistJobDataAfterExecution // lưu JobDataMap
public class SyncOrdersJob extends QuartzJobBean {
  // bean được inject qua SpringBeanJobFactory
  protected void executeInternal(
      JobExecutionContext ctx) { ... }
}

3Quartz cluster chạy thế nào

Không có master. Mọi node dùng chung bảng QRTZ_* và giành khoá dòng TRIGGER_ACCESS; node nhanh tay chạy, mỗi lần kích hoạt chỉ chạy trên một node.

flowchart TD
  A["Node A"] --> L["SELECT ... FOR UPDATE trên QRTZ_LOCKS"]
  B["Node B"] --> L
  L -->|"A giành được"| F["Ghi QRTZ_FIRED_TRIGGERS, chạy job"]
  L -->|"B chờ khoá"| W["Không còn thấy trigger đó"]
  F -.->|"A chết, hết check-in"| R["Node khác chạy lại job"]

4Misfire: lỡ giờ thì sao

Trigger lỡ giờ quá misfireThreshold (60 giây) thì Quartz áp misfire instruction. App tắt 3 giờ, job 5 phút: chạy bù 1 lần hay 36 lần.

Instruction Hành vi Hợp với
FIRE_ONCE_NOW Chạy bù một lần Đồng bộ, dọn dẹp
DO_NOTHING Bỏ, chờ lần kế Tin "chào buổi sáng"
IGNORE_MISFIRE_POLICY Chạy bù tất cả Tính theo kỳ, cần idempotent

5Job lớn: chia chunk

Quartz cluster không chia một job cho nhiều node. Job lập kế hoạch chia theo khoảng user_id; worker giành chunk bằng lease và SKIP LOCKED.

UPDATE job_chunk
SET status = 'RUNNING', owner = :worker,
    lease_until = now() + interval '5 minutes'
WHERE id = (SELECT id FROM job_chunk
  WHERE status = 'PENDING'
     OR (status = 'RUNNING' AND lease_until < now())
  ORDER BY id LIMIT 1
  FOR UPDATE SKIP LOCKED)
RETURNING id, from_user_id, to_user_id;

6Chọn cách chia việc

Dù chọn gì, scheduler chỉ kích hoạt job lập kế hoạch. 10 triệu email với quota 1.000 email/s vẫn mất gần 3 giờ.

  • Bảng chunk + SKIP LOCKED: chỉ cần DB, xem tiến độ bằng SQL
  • Mỗi chunk một message: worker scale theo hàng đợi
  • Spring Batch partitioning: restart từ chỗ dừng, nặng hơn
  • Rate limiter chung cho mọi worker

💡 Ghi nhớ

  • Cluster cần JDBC JobStore và isClustered=true ở mọi node.

  • Job phải idempotent: node chết thì job chạy lại.

  • Chia chunk theo khoảng id, không theo OFFSET.

  • Job theo kỳ lấy kỳ cần xử lý từ dữ liệu.

⭐ Điểm phỏng vấn

Tự trả lời trước, rồi bấm từng câu để xem đáp án.

  • Cluster chặn chạy trùng thế nào?

    Khoá dòng QRTZ_LOCKS với SELECT ... FOR UPDATE.

  • Misfire là gì?

    Lỡ giờ quá ngưỡng, áp chạy bù hoặc bỏ qua.

  • Email 10 triệu user mất 2 ngày?

    Chia chunk, worker giành lease, khoá idempotent mỗi email.

⚠️ Lỗi thường gặp

  • Đồng hồ các node lệch: trigger chạy sai giờ, job chạy hai lần.

  • Chạy một instance không bật cluster trỏ vào cùng bảng QRTZ_*.

  • Đánh dấu chunk xong mà không kiểm tra owner, ghi đè worker đã nhận lại.

@Scheduled cộng ShedLock đủ cho “mỗi đêm chạy một job trên một pod”. Khi cần lịch động (người dùng tự hẹn giờ), chạy bù khi lỡ giờ, hay một job quá lớn cho một máy, bạn cần một scheduler thật và một cách chia việc. Bài này nói về Quartz cluster và cách chia nhỏ job lớn. Nên đọc trước cron job và @Scheduled, nhất là phần chạy trên nhiều instance.

Sơ đồ tóm tắt:

flowchart LR
  T[Trigger: cron, simple] --> S[Scheduler trên mỗi node]
  S -->|"SELECT ... FOR UPDATE trên QRTZ_LOCKS"| DB[(Bảng QRTZ_* dùng chung)]
  S --> J[Job planner chạy trên 1 node]
  J -->|chia khoảng user_id| C[(Bảng job_chunk)]
  W1[Worker 1] -->|SKIP LOCKED + lease| C
  W2[Worker 2] -->|SKIP LOCKED + lease| C
  W3[Worker N] -->|SKIP LOCKED + lease| C

1. Mô hình của Quartz

Ý chính: Job là code chạy; JobDetail là một “bản đăng ký” của Job có tên và dữ liệu; Trigger quyết định khi nào chạy; Scheduler điều phối bằng một thread pool; JobStore lưu tất cả.

Thành phần Vai trò Ghi chú
Job interface có execute(JobExecutionContext) code nghiệp vụ
JobDetail Job + khoá (JobKey) + JobDataMap + cờ durable, requestsRecovery một class Job có thể có nhiều JobDetail khác dữ liệu
Trigger lịch: CronTrigger, SimpleTrigger (lặp N lần mỗi X giây), CalendarIntervalTrigger một JobDetail có nhiều trigger; trigger có độ ưu tiên và múi giờ
Scheduler lấy trigger tới hạn, giao cho thread pool org.quartz.threadPool.threadCount, Spring Boot mặc định 10
JobStore RAMJobStore (mất khi restart) hoặc JDBC JobStore (bảng QRTZ_*) cluster và chạy bù sau restart cần JDBC
  • Mỗi lần trigger kích hoạt, JobFactory tạo một instance mới của class Job. Đừng giữ trạng thái trong field của Job; Spring Boot dùng SpringBeanJobFactory để inject bean vào job.
  • Khác với @Scheduled: lịch tạo được lúc chạy qua API (scheduler.scheduleJob(...)), sống qua restart, có thể tạm dừng, đổi lịch, chạy ngay theo yêu cầu.

1.1. Hai annotation hay bị hỏi

Ý chính: @DisallowConcurrentExecution cấm hai lần chạy cùng một JobDetail chồng lên nhau; @PersistJobDataAfterExecution ghi lại JobDataMap sau mỗi lần chạy. Dùng cái thứ hai thì gần như luôn cần cái thứ nhất.

  • @DisallowConcurrentExecution áp theo JobKey, không theo class: hai JobDetail cùng class (ví dụ đồng bộ hai merchant) vẫn chạy song song được. Trong cluster nó cũng có hiệu lực giữa các node, vì trạng thái “đang chạy” nằm trong database.
  • Job kéo dài hơn chu kỳ: lần kích hoạt tiếp theo phải chờ, và nếu chờ quá misfireThreshold thì thành misfire.
  • @PersistJobDataAfterExecution hợp với bộ đếm hay “lần cuối đồng bộ tới id nào”. Thiếu @DisallowConcurrentExecution thì hai lần chạy song song ghi đè JobDataMap của nhau.
Một Quartz job trong Spring Boot
@DisallowConcurrentExecution
@PersistJobDataAfterExecution
public class SyncOrdersJob extends QuartzJobBean {

    private final OrderSyncService sync;                 // inject qua SpringBeanJobFactory
    SyncOrdersJob(OrderSyncService sync) { this.sync = sync; }

    @Override
    protected void executeInternal(JobExecutionContext ctx) throws JobExecutionException {
        JobDataMap data = ctx.getJobDetail().getJobDataMap();
        long lastId = data.getLongValue("lastSyncedId");
        long newLast = sync.syncAfter(lastId, 5_000);    // idempotent: upsert theo id
        data.put("lastSyncedId", newLast);               // được ghi lại nhờ @PersistJobDataAfterExecution
    }
}

@Configuration
class QuartzJobs {
    @Bean
    JobDetail syncOrdersJob() {
        return JobBuilder.newJob(SyncOrdersJob.class)
                .withIdentity("sync-orders")
                .usingJobData("lastSyncedId", 0L)
                .storeDurably()
                .requestRecovery()                        // node chết giữa chừng thì node khác chạy lại
                .build();
    }

    @Bean
    Trigger syncOrdersTrigger(JobDetail syncOrdersJob) {
        return TriggerBuilder.newTrigger()
                .forJob(syncOrdersJob)
                .withIdentity("sync-orders-every-5m")
                .withSchedule(CronScheduleBuilder.cronSchedule("0 */5 * * * ?")
                        .inTimeZone(TimeZone.getTimeZone("Asia/Ho_Chi_Minh"))
                        .withMisfireHandlingInstructionFireAndProceed())   // lỡ giờ: chạy bù một lần
                .build();
    }
}
spring.quartz.job-store-type=jdbc
spring.quartz.jdbc.initialize-schema=never          # tạo bảng QRTZ_* bằng Flyway/Liquibase
spring.quartz.properties.org.quartz.scheduler.instanceId=AUTO
spring.quartz.properties.org.quartz.jobStore.isClustered=true
spring.quartz.properties.org.quartz.threadPool.threadCount=10

Lưu ý: cron của Quartz có giây ở đầu và dùng ? cho một trong hai field ngày; xem phần ba “phương ngữ” cron ở bài cron job.

2. Quartz cluster chạy thế nào

Ý chính: không có node “master”. Mọi node cùng đọc bảng QRTZ_*; muốn lấy trigger tới hạn, node phải giành khoá dòng TRIGGER_ACCESS trong QRTZ_LOCKS, ghi trigger đã kích hoạt vào QRTZ_FIRED_TRIGGERS, rồi mới nhả khoá. Node nào nhanh tay thì chạy.

  1. Bật org.quartz.jobStore.isClustered=true, mỗi node có instanceId riêng (AUTO), cùng instanceName, cùng database.
  2. Vòng lặp của scheduler: SELECT * FROM QRTZ_LOCKS WHERE SCHED_NAME = ? AND LOCK_NAME = 'TRIGGER_ACCESS' FOR UPDATE, lấy các trigger sắp tới hạn, đánh dấu ACQUIRED, commit. Node khác bị chặn ở câu FOR UPDATE tới khi khoá được nhả, rồi không thấy trigger đó nữa.
  3. Mỗi node định kỳ check-in vào QRTZ_SCHEDULER_STATE (clusterCheckinInterval). Node quá lâu không check-in bị coi là chết; node khác lấy lại các trigger nó đang giữ và chạy lại job có requestsRecovery=true.
  4. Phân tải không đều và không đảm bảo: node nào giành khoá trước thì nhận. Quartz cluster để chịu lỗi và không chạy trùng, không để chia một job lớn.
  • Không bao giờ chạy một instance không bật cluster trỏ vào cùng bảng: nó không giành khoá và sẽ chạy trùng.
  • Bảng QRTZ_* là điểm nghẽn ở quy mô lớn: hàng nghìn trigger mỗi giây làm khoá TRIGGER_ACCESS thành hàng đợi. Quartz hợp với hàng trăm, hàng nghìn job theo lịch, không hợp với hàng triệu hẹn giờ riêng lẻ (dùng hàng đợi có delay hoặc timing wheel).

3. Misfire: lỡ giờ thì sao

Ý chính: trigger lỡ giờ khi mọi thread đều bận, scheduler đang tắt, hoặc job trước còn chạy (với @DisallowConcurrentExecution). Lỡ quá misfireThreshold (mặc định 60 giây) thì Quartz áp misfire instruction của trigger đó.

Instruction (CronTrigger) Hành vi Hợp với
FIRE_ONCE_NOW (smart policy mặc định của cron) chạy bù một lần ngay, rồi theo lịch đồng bộ, dọn dẹp: chạy muộn tốt hơn không chạy
DO_NOTHING bỏ các lần lỡ, chờ lần kế tiếp theo lịch báo cáo theo giờ đã không còn ý nghĩa, gửi tin “chào buổi sáng”
IGNORE_MISFIRE_POLICY chạy bù tất cả lần đã lỡ, liên tiếp việc tính theo từng kỳ không được thiếu kỳ nào (cần idempotent theo kỳ)
  • Ứng dụng tắt 3 giờ, job chạy mỗi 5 phút: FIRE_ONCE_NOW chạy 1 lần, IGNORE_MISFIRE_POLICY chạy 36 lần liền khi khởi động.
  • Job theo kỳ (tính phí theo ngày) nên lấy kỳ cần xử lý từ dữ liệu (“ngày cuối đã tính”), không từ thời điểm job chạy; vậy chạy bù mấy lần cũng đúng.

4. Job lớn: chia thành chunk cho nhiều worker

Ý chính: scheduler chỉ nên kích hoạt, không nên tự làm hết việc nặng. Một job lập kế hoạch chạy trên một node, chia việc thành nhiều chunk nhỏ có trạng thái; nhiều worker trên mọi node giành chunk bằng lease, làm, đánh dấu xong. Worker chết thì lease hết hạn và chunk được giành lại.

Ví dụ từ một câu phỏng vấn: gửi email cho 10 triệu user, chạy tuần tự mất 2 ngày (khoảng 17 ms mỗi email).

  • Chia: theo khoảng user_id cố định (10.000 user mỗi chunk → 1.000 chunk), không theo OFFSET (dữ liệu thay đổi làm lệch trang).
  • Giành việc: SELECT … FOR UPDATE SKIP LOCKED để mỗi worker lấy một chunk khác nhau mà không chờ nhau; đặt owner, lease_until.
  • Idempotent: mỗi email có khoá campaign_id + user_id (bảng UNIQUE hoặc bảng trạng thái theo user), chunk làm lại không gửi trùng.
  • Tốc độ thật bị giới hạn bởi nhà cung cấp email: 50 luồng song song nhưng quota 1.000 email/s thì 10 triệu email mất gần 3 giờ; rate limiter chung cho mọi worker.
  • Theo dõi: đếm chunk theo trạng thái, ETA, nút dừng (worker kiểm tra cờ trước mỗi chunk).
-- Worker giành một chunk: chunk chưa ai làm, hoặc chunk có lease đã hết hạn
UPDATE job_chunk
SET status = 'RUNNING', owner = :worker, lease_until = now() + interval '5 minutes', attempts = attempts + 1
WHERE id = (
    SELECT id FROM job_chunk
    WHERE job_id = :job AND (status = 'PENDING' OR (status = 'RUNNING' AND lease_until < now()))
    ORDER BY id
    LIMIT 1
    FOR UPDATE SKIP LOCKED
)
RETURNING id, from_user_id, to_user_id;

-- Xong: chỉ chủ của lease mới được đánh dấu (worker bị coi là chết thì không ghi đè được)
UPDATE job_chunk SET status = 'DONE', finished_at = now()
WHERE id = :id AND owner = :worker AND status = 'RUNNING';

Bài tập

Bài 1: Mô phỏng worker giành chunk có lease

Chia 10 triệu user thành chunk 10.000 user. 8 worker chạy song song giành chunk; worker-3 chết khi đang giữ chunk đầu tiên nó nhận. Sau khi lease hết hạn, chunk đó phải được làm lại. Kiểm tra: mọi chunk DONE, không chunk nào được đánh dấu xong hai lần.

Lời giải Bài 1
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;

/** Mô phỏng bảng job_chunk: mỗi chunk là một khoảng user_id, worker giành chunk bằng lease. */
public class ChunkedJob {
    enum Status { PENDING, RUNNING, DONE }

    static final class Chunk {
        final int id; final long fromUser; final long toUser;
        Status status = Status.PENDING; String owner; long leaseUntil; int attempts;
        Chunk(int id, long from, long to) { this.id = id; this.fromUser = from; this.toUser = to; }
    }

    private final List<Chunk> chunks = new ArrayList<>();
    private final AtomicLong clock = new AtomicLong();                  // thời gian giả lập (ms)
    private final ConcurrentHashMap<Integer, AtomicInteger> completions = new ConcurrentHashMap<>();
    static final long LEASE_MS = 5_000;

    ChunkedJob(long users, long chunkSize) {
        int id = 0;
        for (long from = 1; from <= users; from += chunkSize)
            chunks.add(new Chunk(id++, from, Math.min(users, from + chunkSize - 1)));
    }

    /** Tương đương: UPDATE job_chunk SET status='RUNNING', owner=?, lease_until=now+5s
     *  WHERE id = (SELECT id FROM job_chunk WHERE status='PENDING'
     *              OR (status='RUNNING' AND lease_until < now) LIMIT 1 FOR UPDATE SKIP LOCKED) */
    synchronized Chunk claim(String worker) {
        long now = clock.get();
        for (Chunk c : chunks) {
            boolean free = c.status == Status.PENDING || (c.status == Status.RUNNING && c.leaseUntil < now);
            if (free) {
                c.status = Status.RUNNING; c.owner = worker; c.leaseUntil = now + LEASE_MS; c.attempts++;
                return c;
            }
        }
        return null;
    }

    /** Chỉ chủ hiện tại của lease mới được đánh dấu DONE (fencing theo owner). */
    synchronized boolean complete(Chunk c, String worker) {
        if (c.status != Status.RUNNING || !worker.equals(c.owner)) return false;
        c.status = Status.DONE;
        completions.computeIfAbsent(c.id, k -> new AtomicInteger()).incrementAndGet();
        return true;
    }

    public static void main(String[] args) throws Exception {
        ChunkedJob job = new ChunkedJob(10_000_000, 10_000);              // 1.000 chunk
        AtomicBoolean crashed = new AtomicBoolean();
        try (ExecutorService pool = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int w = 1; w <= 8; w++) {
                String name = "worker-" + w;
                pool.submit(() -> {
                    Chunk c;
                    while ((c = job.claim(name)) != null) {
                        if (name.equals("worker-3") && crashed.compareAndSet(false, true)) {
                            return null;                                   // chết khi đang giữ một chunk
                        }
                        job.clock.addAndGet(1);                            // "gửi" 10.000 email
                        job.complete(c, name);
                    }
                    return null;
                });
            }
        }
        // Lease của chunk bị bỏ dở hết hạn; một vòng dọn chạy tiếp các chunk còn lại
        job.clock.addAndGet(LEASE_MS + 1);
        Chunk c;
        while ((c = job.claim("worker-recovery")) != null) job.complete(c, "worker-recovery");

        long done = job.chunks.stream().filter(x -> x.status == Status.DONE).count();
        long twice = job.completions.values().stream().filter(v -> v.get() > 1).count();
        long retried = job.chunks.stream().filter(x -> x.attempts > 1).count();
        System.out.println("chunks=" + job.chunks.size() + " done=" + done
                + " doneTwice=" + twice + " retriedAfterCrash=" + retried);
    }
}

Chạy java ChunkedJob.java (JDK 21):

chunks=1000 done=1000 doneTwice=0 retriedAfterCrash=1

synchronized đóng vai khoá dòng của database; owner trong complete là fencing: nếu worker-3 chỉ bị chậm (GC dài) chứ không chết, lúc nó quay lại thì chunk đã thuộc người khác và lệnh đánh dấu của nó bị từ chối. Nhưng email nó đã gửi trước đó thì không thu hồi được, nên việc gửi từng email vẫn phải idempotent theo campaign_id + user_id.

Bài 2: Chọn misfire instruction

Ứng dụng tắt từ 01:00 tới 04:00 để bảo trì. Chọn misfire instruction cho: (a) job đồng bộ đơn hàng mỗi 5 phút, (b) job gửi “bản tin buổi sáng” lúc 03:00, (c) job tính lãi theo ngày lúc 02:00.

Lời giải Bài 2
  • (a) FIRE_ONCE_NOW: một lần đồng bộ lúc 04:00 lấy hết đơn từ mốc cuối cùng (lưu trong JobDataMap hoặc bảng), không cần chạy 36 lần.
  • (b) DO_NOTHING: bản tin 03:00 gửi lúc 04:00 thì có thể vẫn ổn, nhưng nếu ứng dụng chỉ lên lại lúc 10:00 thì “bản tin buổi sáng” đã vô nghĩa. Nếu vẫn muốn gửi muộn có giới hạn, tự kiểm tra trong job: quá 07:00 thì bỏ.
  • (c) Không được thiếu kỳ nào, nhưng cũng không nên dựa vào số lần Quartz chạy bù: job đọc “ngày cuối đã tính lãi” rồi tính tiếp từng ngày tới hôm qua, mỗi ngày một transaction có khoá duy nhất (account_id, date). Với cách đó FIRE_ONCE_NOW là đủ và chạy lại bao nhiêu lần cũng đúng.

Ghi nhớ

  • Phân biệt được Job, JobDetail, Trigger, JobStore và biết vì sao Job không giữ trạng thái trong field.
  • Giải thích được cơ chế khoá QRTZ_LOCKS giúp cluster không chạy trùng, và vì sao cần đồng bộ giờ.
  • Biết @DisallowConcurrentExecution áp theo JobDetail, và đi cùng @PersistJobDataAfterExecution.
  • Chọn được misfire instruction theo bản chất của job.
  • Thiết kế được cách chia job lớn thành chunk có lease, idempotent và có giới hạn tốc độ.

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

Junior

Job, JobDetail và Trigger trong Quartz khác nhau thế nào?

Job là class chứa code chạy; JobDetail là một bản đăng ký của Job với tên và dữ liệu riêng; Trigger là lịch quyết định khi nào JobDetail chạy.

Một class Job có thể có nhiều JobDetail (mỗi merchant một bản), một JobDetail có thể có nhiều Trigger (giờ hành chính và cuối tuần khác nhau).

Vì sao Quartz tạo một instance Job mới cho mỗi lần chạy?

Để các lần chạy không chia sẻ trạng thái qua field: hai trigger kích hoạt cùng lúc trên một instance sẽ có race condition, và trong cluster thì field trên một JVM vô nghĩa với node khác.

Trạng thái cần giữ giữa các lần chạy để trong JobDataMap (lưu trong JobStore) hoặc trong database nghiệp vụ.

Mid

Quartz cluster đảm bảo một job không chạy trên hai node cùng lúc thế nào?

Các node dùng chung bảng QRTZ_*; để lấy trigger tới hạn, node phải giành khoá dòng TRIGGER_ACCESS trong QRTZ_LOCKS bằng SELECT … FOR UPDATE, đánh dấu trigger đã được nhận rồi mới nhả. Node khác chờ khoá xong thì không còn thấy trigger đó.

Điều kiện: isClustered=true trên mọi node, instanceId khác nhau, cùng database, đồng hồ đồng bộ, và không có instance không bật cluster trỏ vào cùng bảng. Node chết thì node khác phát hiện qua check-in và chạy lại job có requestsRecovery, nên job vẫn phải idempotent.

@DisallowConcurrentExecution làm gì? Hai JobDetail cùng class có chạy song song được không?

Nó cấm hai lần chạy chồng nhau của cùng một JobDetail (theo JobKey); hai JobDetail khác nhau dùng chung class vẫn chạy song song được.

Trong cluster cấm này có hiệu lực giữa các node vì dựa vào trạng thái trong database. Job chạy lâu hơn chu kỳ thì lần sau phải chờ và có thể thành misfire. Dùng cùng @PersistJobDataAfterExecution để hai lần chạy không ghi đè JobDataMap của nhau.

Misfire trong Quartz là gì và bạn xử lý thế nào?

Là khi trigger lỡ giờ chạy quá misfireThreshold (mặc định 60 giây), do scheduler tắt, hết thread, hoặc job trước còn chạy. Quartz áp misfire instruction của trigger: chạy bù một lần, bỏ qua, hoặc chạy bù tất cả.

Chọn theo nghiệp vụ: đồng bộ thì chạy bù một lần; tin theo giờ thì bỏ; việc theo kỳ thì cho job tự tính kỳ còn thiếu từ dữ liệu, không dựa vào số lần chạy bù.

Senior

Một job gửi email cho 10 triệu user chạy mất 2 ngày. Bạn thiết kế lại thế nào?

Tách thành job lập kế hoạch (chạy một lần, trên một node) chia user theo khoảng id thành chunk, và nhiều worker trên nhiều node giành chunk bằng FOR UPDATE SKIP LOCKED có lease; mỗi email idempotent theo campaign_id + user_id; tốc độ chung bị giới hạn theo quota nhà cung cấp email.

  • 2 ngày cho 10 triệu là ~17 ms/email tuần tự: nút thắt là chờ mạng, nên song song hoá là đúng hướng.
  • Tính lại bằng quota: 1.000 email/s là gần 3 giờ; nhanh hơn nữa phải nâng gói hoặc chia nhiều nhà cung cấp.
  • Chunk có trạng thái, số lần thử, lỗi cuối; chunk lỗi nhiều lần thì dừng để người xem.
  • Theo dõi tiến độ, ETA, nút dừng khẩn cấp; tôn trọng tuỳ chọn hủy nhận tin tại thời điểm gửi.
  • Cách khác: mỗi chunk một message trên queue, hoặc Spring Batch remote partitioning.
Khi nào chọn Quartz cluster, khi nào ShedLock, khi nào Kubernetes CronJob?

ShedLock khi chỉ cần “job cố định chạy trên một instance”; Quartz khi cần lịch động tạo lúc chạy, chạy bù, tạm dừng/đổi lịch qua API và chịu lỗi giữa node; Kubernetes CronJob khi job là một tiến trình độc lập, chạy xong là thoát.

  • ShedLock: nhẹ, một bảng, nhưng không có misfire, không lịch động.
  • Quartz: 11 bảng, khoá database là điểm nghẽn khi số trigger rất lớn; không chia nhỏ job.
  • CronJob: cô lập tài nguyên, concurrencyPolicy: Forbid, nhưng mỗi lần chạy là một pod mới (JVM khởi động chậm), và lịch nằm trong manifest.
  • Hàng triệu hẹn giờ riêng lẻ (nhắc lịch từng user): không cái nào ở trên, dùng hàng đợi có delay hoặc sorted set/timing wheel.
Worker giữ chunk bị GC dừng 6 phút, lease 5 phút hết hạn, worker khác đã nhận lại chunk. Chuyện gì xảy ra và bạn chặn thế nào?

Hai worker cùng làm một chunk: worker cũ tỉnh dậy và tiếp tục gửi, có thể gửi trùng. Chặn bằng fencing (chỉ chủ hiện tại của lease mới ghi được kết quả) cộng idempotency ở từng tác vụ nhỏ, vì fencing không thu hồi được việc đã làm.

  • UPDATE … WHERE id = ? AND owner = ? (hoặc so sánh số phiên bản/fencing token tăng dần) để worker cũ không ghi được DONE.
  • Worker gia hạn lease định kỳ trong lúc làm (heartbeat), và kiểm tra còn giữ lease trước mỗi lô nhỏ.
  • Từng email có khoá campaign_id + user_id trong bảng UNIQUE: lần gửi thứ hai bị chặn ở đó.
  • Đây là cùng một bài toán với distributed lock hết hạn; xem review distributed lock bằng Redis.

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
scheduler /ˈskedʒ.uː.lɚ/ bộ lập lịch “The scheduler only triggers the planner; workers do the heavy lifting.”
trigger /ˈtrɪɡ.ɚ/ lịch kích hoạt “One job detail can have several triggers in different time zones.”
job store /dʒɑːb stɔːr/ nơi lưu job và trigger “Clustering requires the JDBC job store.”
misfire /ˌmɪsˈfaɪr/ lỡ giờ chạy “After the outage, the misfire policy fired the sync job once.”
row lock /roʊ lɑːk/ khoá dòng “Nodes compete for a row lock on QRTZ_LOCKS before acquiring triggers.”
check-in /ˈtʃek.ɪn/ báo còn sống “A node that stops checking in is considered failed.”
chunk /tʃʌŋk/ phần việc nhỏ “We split ten million users into a thousand chunks.”
lease /liːs/ quyền giữ có thời hạn “A worker holds a five-minute lease and renews it while working.”
fencing /ˈfen.sɪŋ/ chặn chủ cũ “Fencing on the owner column stops a stale worker from marking the chunk done.”
clock skew /klɑːk skjuː/ đồng hồ lệch “Clock skew between nodes can make Quartz recover a job that is still running.”

Ghi chép tự tổng hợp từ tài liệu chính thức và kinh nghiệm thực tế.