java 60 lines · 8 steps

Distributed scheduled jobs with Spring locks

A scheduled reconciliation job uses a JDBC-backed distributed lock so only one node in a cluster runs it at a time.

Explained by highlit

Spring Advanced distributed-locking scheduling concurrency leader-election fault-tolerance

1@Component
2public class InventoryReconciliationJob {
3 
  private static final Logger log = LoggerFactory.getLogger(InventoryReconciliationJob.class);
  private static final String LOCK_KEY = "inventory-reconciliation";
6 
  private final LockRegistry lockRegistry;
  private final InventoryReconciler reconciler;
9 
  public InventoryReconciliationJob(LockRegistry lockRegistry, InventoryReconciler reconciler) {
      this.lockRegistry = lockRegistry;
      this.reconciler = reconciler;
  }
14 
  @Scheduled(cron = "0 */15 * * * *")
  public void reconcile() {
      Lock lock = lockRegistry.obtain(LOCK_KEY);
      boolean acquired;
      try {
          acquired = lock.tryLock(5, TimeUnit.SECONDS);
      } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
          log.warn("Interrupted while acquiring reconciliation lock");
          return;
      }
26 
      if (!acquired) {
          log.debug("Another node holds the reconciliation lock; skipping this run");
          return;
      }
31 
      try {
          ReconciliationResult result = reconciler.run();
          log.info("Reconciled {} SKUs, {} adjustments applied",
                  result.scanned(), result.adjustments());
      } finally {
          try {
              lock.unlock();
          } catch (IllegalStateException e) {
              log.warn("Reconciliation lock expired before release: {}", e.getMessage());
          }
      }
  }
44 
  @Configuration
  static class LockConfig {
47 
      @Bean
      public DefaultLockRepository lockRepository(DataSource dataSource) {
          DefaultLockRepository repository = new DefaultLockRepository(dataSource);
          repository.setTimeToLive(120_000);
          return repository;
      }
54 
      @Bean
      public JdbcLockRegistry lockRegistry(LockRepository lockRepository) {
          return new JdbcLockRegistry(lockRepository);
      }
  }
60}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1A shared lock backed by a database turns a cluster-wide scheduled job into a single-executor operation without a dedicated coordinator.
2Always bound lock acquisition with a timeout and release in a finally block so a failed run never leaves the lock held.
3A time-to-live on the lock guards against nodes that crash mid-run, letting another instance recover the schedule.

Related explainers

python

import threading
from functools import wraps

A thread-safe debounce decorator in Python

decorators debounce threading

Advanced 6 steps

rust

use axum::{
    extract::State,
    http::StatusCode,
    Json,

Idempotent webhook handling in Axum

deduplication idempotency shared-state

Intermediate 8 steps

package middleware
 
import (
	"log"

Per-IP rate limiting middleware in Gin

rate-limiting middleware concurrency

Intermediate 8 steps

java

package com.example.time;
 
import java.time.Duration;
import java.time.Instant;

Adding ISO-8601 durations across time zones in Java

date-time iso-8601 parsing

Intermediate 7 steps

java

import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.regex.Pattern;

Ranking the most frequent words in Java

streams regex grouping

Intermediate 7 steps

java

public final class HttpHeaders {
 
    private final NavigableMap<String, List<String>> values =
            new TreeMap<>(String.CASE_INSENSITIVE_ORDER);