Java Cron Jobs & Recurring Tasks: A Complete Scheduling Guide

ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

// Run every hour
executor.scheduleAtFixedRate(
    () -> System.out.println("Running hourly task"),
    0,
    1,
    TimeUnit.HOURS
);

// Run every day at fixed delay
executor.scheduleWithFixedDelay(
    () -> cleanupOldFiles(),
    0,
    24,
    TimeUnit.HOURS
);

@Component
public class ScheduledTasks {
    
    @Scheduled(cron = "0 0 9 * * *")
    public void dailyReportAt9am() {
        generateReport();
    }
    
    @Scheduled(fixedRate = 60000)
    public void everyMinute() {
        checkHealth();
    }
    
    @Scheduled(cron = "0 0 0 * * MON")
    public void everyMondayMidnight() {
        weeklyCleanup();
    }
}

@EnableScheduling
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// Define a job
public class ReportJob implements Job {
    @Override
    public void execute(JobExecutionContext context) {
        generateReport();
    }
}

// Schedule it
JobDetail job = JobBuilder.newJob(ReportJob.class)
    .withIdentity("dailyReport")
    .build();

CronTrigger trigger = TriggerBuilder.newTrigger()
    .withIdentity("dailyTrigger")
    .withSchedule(CronScheduleBuilder.cronSchedule("0 0 9 * * ?"))
    .build();

scheduler.scheduleJob(job, trigger);

// Schedule a recurring job with lambdas
BackgroundJob.scheduleRecurrently(
    "daily-report",
    Cron.daily(9, 0),
    () -> reportService.generateDailyReport()
);

// Or use cron expression directly
BackgroundJob.scheduleRecurrently(
    "weekly-cleanup",
    "0 0 * * 1",
    () -> cleanupService.weeklyCleanup()
);

// Or use annotations (Spring Boot example)
@Recurring(id = "hourly-sync", cron = "0 * * * *")
public void syncData() {
    // runs every hour
}

Cron.minutely()           // Every minute
Cron.hourly()             // Every hour at :00
Cron.hourly(30)           // Every hour at :30
Cron.daily()              // Every day at midnight
Cron.daily(9, 0)          // Every day at 9:00 AM
Cron.weekly()             // Every Sunday at midnight
Cron.monthly()            // First of month at midnight
Cron.monthly(15, 14, 30)  // 15th of month at 2:30 PM

// Run every 30 seconds
BackgroundJob.scheduleRecurrently(
    "health-check",
    Duration.ofSeconds(30),
    () -> healthService.check()
);

// Run every 2 hours
BackgroundJob.scheduleRecurrently(
    "sync-data",
    Duration.ofHours(2),
    () -> syncService.sync()
);

@Component
public class ReportService {

    @Recurring(id = "daily-report", cron = "0 9 * * *")
    public void generateDailyReport() {
        // This runs every day at 9:00 AM
    }

    @Recurring(id = "weekly-cleanup", cron = "0 0 * * 1")
    public void weeklyCleanup() {
        // This runs every Monday at midnight
    }
}

@Service
public class ScheduledJobsConfig {
    
    private final ReportService reportService;
    private final CleanupService cleanupService;
    
    @PostConstruct
    public void registerRecurringJobs() {
        // Daily at 9 AM
        BackgroundJob.scheduleRecurrently(
            "daily-report",
            Cron.daily(9, 0),
            reportService::generateDailyReport
        );
        
        // Every Monday at midnight
        BackgroundJob.scheduleRecurrently(
            "weekly-cleanup",
            "0 0 * * 1",
            cleanupService::weeklyCleanup
        );
        
        // Every 15 minutes
        BackgroundJob.scheduleRecurrently(
            "health-check",
            "*/15 * * * *",
            () -> healthService.check()
        );
    }
}

// Run once immediately
BackgroundJob.enqueue(() -> syncService.sync());

// Then continue on schedule
BackgroundJob.scheduleRecurrently(
    "hourly-sync",
    Cron.hourly(),
    () -> syncService.sync()
);

// Monday through Friday at 9 AM
BackgroundJob.scheduleRecurrently(
    "weekday-report",
    "0 9 * * 1-5",
    () -> reportService.generate()
);

// 9 AM to 5 PM, every 5 minutes, weekdays only
BackgroundJob.scheduleRecurrently(
    "business-hours-check",
    "*/5 9-17 * * 1-5",
    () -> alertService.checkSystems()
);

BackgroundJob.scheduleRecurrently(
    "month-end-report",
    Cron.daily(23, 59),
    () -> {
        if (isLastDayOfMonth()) {
            reportService.monthEndReport();
        }
    }
);

private boolean isLastDayOfMonth() {
    LocalDate today = LocalDate.now();
    return today.equals(today.withDayOfMonth(today.lengthOfMonth()));
}

// Last day of every month at midnight (Pro only)
BackgroundJob.scheduleRecurrently(
    "month-end-report",
    "0 0 L * *",
    () -> reportService.monthEndReport()
);

// Last Friday of every month at 5 PM
BackgroundJob.scheduleRecurrently(
    "monthly-review",
    "0 17 * * 5L",
    () -> reviewService.monthlyReview()
);

// This runs at 9 AM New York time, regardless of server location
BackgroundJob.scheduleRecurrently(
    "nyc-report",
    "0 9 * * *",
    ZoneId.of("America/New_York"),
    () -> reportService.generate()
);