SpringBoot使用SchedulingConfigurer实现多个定时任务多机器部署问题(推荐)

下面将详细讲解如何使用SchedulingConfigurer实现多个定时任务多机器部署的方法。

什么是SchedulingConfigurer

SchedulingConfigurer是Spring框架中的一个接口，用于配置定时任务的线程池和任务注册中心等。通过实现该接口，我们可以自定义定时任务的配置信息。

实现多个定时任务多机器部署的步骤

下面是实现多个定时任务多机器部署的详细步骤：

1. 实现SchedulingConfigurer接口

@Configuration
@EnableScheduling
public class ScheduledConfig implements SchedulingConfigurer {

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(taskExecutor());
        taskRegistrar.addTriggerTask(new Runnable() {
            @Override
            public void run() {
                //定时任务的业务逻辑代码
            }
        }, new Trigger() {
            @Override
            public Date nextExecutionTime(TriggerContext triggerContext) {
                //定时任务的执行时间
            }
        });
        //注册其他定时任务...
    }

    @Bean(destroyMethod="shutdown")
    public Executor taskExecutor() {
        return Executors.newScheduledThreadPool(10);
    }
}

2. 配置定时任务执行时间

定时任务的执行时间可以通过Trigger接口的nextExecutionTime方法进行配置。我们可以根据自己的业务需求来选择不同的执行方式，例如：

固定时间间隔执行任务

new Trigger() {
    @Override
    public Date nextExecutionTime(TriggerContext triggerContext) {
        //当前时间
        Date currentTime = new Date();
        //下一次执行时间，固定间隔5秒
        Date nextExecutionTime = new Date(currentTime.getTime() + 5000);
        return nextExecutionTime;
    }
}

根据cron表达式执行任务

new CronTrigger("0/10 * * * * ?");

3. 部署多个实例

如果需要在多台机器上部署定时任务，需要确保每台机器上的任务执行时间是一致的，并且不会出现重复执行的情况。为了解决这个问题，我们可以使用Redis作为任务注册中心，使用RedisLock来保证任务在多台机器上的唯一性。

@Configuration
@EnableScheduling
public class ScheduledConfig implements SchedulingConfigurer {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(taskExecutor());
        taskRegistrar.addTriggerTask(new Runnable() {
            @Override
            public void run() {
                //获取分布式锁
                DistributedLock lock = new RedisLock(stringRedisTemplate, "task-lock");
                if (lock.tryLock()) {
                    try {
                        //定时任务的业务逻辑代码
                    } finally {
                        //释放分布式锁
                        lock.unlock();
                    }
                }
            }
        }, new Trigger() {
            @Override
            public Date nextExecutionTime(TriggerContext triggerContext) {
                //当前时间
                Date currentTime = new Date();
                //下一次执行时间，固定间隔5秒
                Date nextExecutionTime = new Date(currentTime.getTime() + 5000);
                return nextExecutionTime;
            }
        });
        //注册其他定时任务...
    }

    @Bean(destroyMethod="shutdown")
    public Executor taskExecutor() {
        return Executors.newScheduledThreadPool(10);
    }

    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        return new StringRedisTemplate(factory);
    }
}

上面的代码中，我们使用RedisLock来获取分布式锁，保证在多台机器上只有一个任务能够执行。同时，我们使用Redis作为任务注册中心，确保任务的执行时间是一致的。

示例说明

下面我们通过两个示例说明如何使用SchedulingConfigurer实现多个定时任务多机器部署的方法。

示例一：使用固定时间间隔执行任务

我们定义一个定时任务，在每隔5秒钟执行一次，并打印当前任务的执行时间。

@Configuration
@EnableScheduling
public class ScheduledConfig implements SchedulingConfigurer {

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(taskExecutor());
        taskRegistrar.addTriggerTask(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前时间：" + new Date());
            }
        }, new Trigger() {
            @Override
            public Date nextExecutionTime(TriggerContext triggerContext) {
                //当前时间
                Date currentTime = new Date();
                //下一次执行时间，固定间隔5秒
                Date nextExecutionTime = new Date(currentTime.getTime() + 5000);
                return nextExecutionTime;
            }
        });
    }

    @Bean(destroyMethod="shutdown")
    public Executor taskExecutor() {
        return Executors.newScheduledThreadPool(10);
    }
}

示例二：使用cron表达式执行任务

我们定义一个定时任务，在每分钟的0秒、10秒、20秒、30秒、40秒和50秒执行一次，并打印当前任务的执行时间。

@Configuration
@EnableScheduling
public class ScheduledConfig implements SchedulingConfigurer {

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(taskExecutor());
        taskRegistrar.addTriggerTask(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前时间：" + new Date());
            }
        }, new Trigger() {
            @Override
            public Date nextExecutionTime(TriggerContext triggerContext) {
                //使用crontab表达式
                String cron = "0/10 * * * * ?";
                CronTrigger trigger = new CronTrigger(cron);
                return trigger.nextExecutionTime(triggerContext);
            }
        });
    }

    @Bean(destroyMethod="shutdown")
    public Executor taskExecutor() {
        return Executors.newScheduledThreadPool(10);
    }
}

上面的示例代码中，我们通过使用SchedulingConfigurer来实现了多个定时任务多机器部署的功能，并且分别通过固定时间间隔和cron表达式两种方式来执行定时任务。