Spring Boot: Scheduled Tasks?

Question

Accepted Answer

**@Scheduled** — executing tasks on a **schedule (cron)** without an external scheduler.

**Simple analogy:** @Scheduled is like an alarm clock. You set it to "every 5 minutes" or "every Monday at 9:00" — Spring rings at the right time. Think of it like a weekly cleaning service: you give them a key (enable scheduling) and a schedule ("every Friday at 6 PM"), and they come automatically without you calling each time.

**Why it matters:** Many applications need periodic background work — cleaning old data, syncing external APIs, sending batch emails, refreshing caches, generating reports. Without scheduled tasks, you would need external tools (cron, Kubernetes CronJobs) or manual triggers.

**Enabling:**
```java
@SpringBootApplication
@EnableScheduling
public class MyApp { ... }
```

**Examples:**
```java
@Service
@Slf4j
public class ScheduledTasks {

@Scheduled(fixedRate = 5000)  // Every 5 seconds (from start of previous)
    public void checkHealth() {
        log.info("Health check at {}", LocalDateTime.now());
    }

@Scheduled(fixedDelay = 10000)  // 10 seconds after previous COMPLETION
    public void syncData() {
        log.info("Data sync completed");
    }

@Scheduled(cron = "0 0 2 * * ?")  // Every day at 2:00 AM
    public void cleanupOldRecords() {
        repository.deleteOlderThan(LocalDate.now().minusYears(1));
    }

@Scheduled(cron = "0 */5 * * * *")  // Every 5 minutes
    public void refreshCache() {
        cacheManager.getCache("products").clear();
    }

@Scheduled(cron = "0 0 9 * * MON-FRI")  // Weekdays at 9 AM
    public void sendDailyDigest() {
        emailService.sendDigest();
    }
}
```

**Pool configuration:**
```yaml
spring:
  task:
    scheduling:
      pool:
        size: 5  # 5 threads for scheduled tasks
      thread-name-prefix: scheduled-task-
      shutdown:
        await-termination: true
        await-termination-period: 30s
```

**Common mistakes:**
- **Not handling exceptions** — an uncaught exception kills the schedule silently. Always wrap in try-catch:
```java
@Scheduled(fixedRate = 60000)
public void riskyTask() {
    try {
        doWork();
    } catch (Exception e) {
        log.error("Scheduled task failed", e);
    }
}
```
- **Using `fixedRate` for long tasks** — if the task takes longer than the interval, multiple threads execute it simultaneously. Use `fixedDelay` instead.
- **Not configuring pool size** — default is 1 thread. If you have 10 scheduled tasks and one runs for 5 minutes, the other 9 wait.

**For production — Quartz Scheduler:**
```java
@Configuration
public class QuartzConfig {
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setJobDetails(jobDetail());
        factory.setTriggers(trigger());
        factory.setOverwriteExistingJobs(true);
        return factory;
    }
}
```

**@Scheduled vs Quartz:**
- @Scheduled — simple, in-memory, for periodic tasks, no persistence.
- Quartz — dynamic scheduling, clustering across nodes, persistence in DB, misfire handling, job chaining.

Java: Spring Boot: Scheduled Tasks?