使用Java实现动态定时任务的代码（一）：
import java.util.HashMap;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
public class DynamicTaskManager {
private Map<String, Timer> scheduledTasks = new HashMap<>();
public void addTask(String taskId, Runnable task, long delay, long period) {
Timer timer = new Timer();
TimerTask timerTask = new TimerTask() {
@Override
public void run() {
task.run();
}
};
timer.schedule(timerTask, delay, period);
scheduledTasks.put(taskId, timer);
}
public void updateTask(String taskId, long delay, long period) {
Timer timer = scheduledTasks.get(taskId);
if (timer != null) {
timer.cancel();
TimerTask timerTask = new TimerTask() {
@Override
public void run() {
// 执行更新后的定时任务逻辑代码
}
};
timer.schedule(timerTask, delay, period);
}
}
public void removeTask(String taskId) {
Timer timer = scheduledTasks.get(taskId);
if (timer != null) {
timer.cancel();
scheduledTasks.remove(taskId);
}
}
public void stopTask(String taskId) {
Timer timer = scheduledTasks.get(taskId);
if (timer != null) {
timer.cancel();
}
}
public void startTask(String taskId) {
Timer timer = scheduledTasks.get(taskId);
if (timer != null) {
TimerTask timerTask = new TimerTask() {
@Override
public void run() {
// 执行启动后的定时任务逻辑代码
}
};
timer.schedule(timerTask, 0);
}
}
}
使用示例：
public class Main {
public static void main(String[] args) {
DynamicTaskManager taskManager = new DynamicTaskManager();
// 添加定时任务
Runnable task1 = new Runnable() {
@Override
public void run() {
System.out.println("Task 1");
}
};
taskManager.addTask("task1", task1, 0, 2000);
// 修改定时任务
taskManager.updateTask("task1", 1000, 3000);
// 删除定时任务
taskManager.removeTask("task1");
// 添加定时任务
Runnable task2 = new Runnable() {
@Override
public void run() {
System.out.println("Task 2");
}
};
taskManager.addTask("task2", task2, 0, 3000);
// 停止定时任务
taskManager.stopTask("task2");
// 启动定时任务
taskManager.startTask("task2");
// 停止所有定时任务
taskManager.scheduledTasks.values().forEach(Timer::cancel);
taskManager.scheduledTasks.clear();
}
}
在上述示例中，DynamicTaskManager类实现了动态定时任务的添加、修改、删除、停止和启动功能。通过Timer类来实现定时任务的管理，通过TimerTask类来定义定时任务的逻辑代码。
在Main类中，创建了一个DynamicTaskManager对象，并使用其中的方法来操作定时任务的添加、修改、删除、停止和启动。
Timer类是一种简单的定时任务调度器，它在单个线程中顺序执行定时任务。如果需要更复杂的定时任务管理功能，可以考虑使用ScheduledExecutorService`接口实现，它支持多线程执行定时任务，并且提供了更灵活的配置选项。
使用SchedulingConfigurer接口实现动态定时任务的代码（二）：
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.CronTask;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ScheduledFuture;
@Configuration
@EnableScheduling
public class DynamicTaskConfig implements SchedulingConfigurer {
private ScheduledTaskRegistrar taskRegistrar;
private Map<String, ScheduledFuture<?>> taskFutures = new HashMap<>();
@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
this.taskRegistrar = taskRegistrar;
}
public void addTask(String taskId, Runnable task, String cronExpression) {
CronTask cronTask = new CronTask(task, cronExpression);
ScheduledFuture<?> future = taskRegistrar.scheduleCronTask(cronTask);
taskFutures.put(taskId, future);
}
public void removeTask(String taskId) {
ScheduledFuture<?> future = taskFutures.get(taskId);
if (future != null) {
future.cancel(true);
taskFutures.remove(taskId);
}
}
public void updateTask(String taskId, String cronExpression) {
removeTask(taskId);
Runnable task = taskRegistrar.getCronTask(taskId).getRunnable();
addTask(taskId, task, cronExpression);
}
public void startTask(String taskId) {
ScheduledFuture<?> future = taskFutures.get(taskId);
if (future != null && future.isCancelled()) {
CronTask cronTask = taskRegistrar.getCronTask(taskId);
ScheduledFuture<?> newFuture = taskRegistrar.scheduleCronTask(cronTask);
taskFutures.put(taskId, newFuture);
}
}
public void stopTask(String taskId) {
removeTask(taskId);
}
@Component
public class DynamicTask implements Runnable {
@Override
public void run() {
// 定时任务逻辑代码
System.out.println("Dynamic Task: " + new Date());
}
}
}
使用：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import java.util.concurrent.TimeUnit;
@SpringBootApplication
public class Application {
@Autowired
private DynamicTaskConfig dynamicTaskConfig;
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
public void runTasks() {
// 添加新任务
dynamicTaskConfig.addTask("task1", new Runnable() {
@Override
public void run() {
System.out.println("Task 1");
}
}, "0/5 * * * * *");
// 修改任务
dynamicTaskConfig.updateTask("task1", "0/10 * * * * *");
// 启动任务
dynamicTaskConfig.startTask("task1");
// 停止任务
dynamicTaskConfig.stopTask("task1");
// 删除任务
dynamicTaskConfig.removeTask("task1");
// 添加新任务
dynamicTaskConfig.addTask("task2", new Runnable() {
@Override
public void run() {
System.out.println("Task 2");
}
}, "0/3 * * * * *");
try {
TimeUnit.SECONDS.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 停止所有任务
dynamicTaskConfig.configureTasks(null);
}
}
在上述示例中，DynamicTaskConfig类实现了SchedulingConfigurer接口，通过taskRegistrar对象来进行定时任务的管理。可以使用addTask方法添加新的定时任务，使用removeTask方法删除任务，使用updateTask方法修改任务的Cron表达式，使用startTask方法启动任务，使用stopTask方法停止任务。
在DynamicTask类中，实现了Runnable接口，并在run方法中定义了定时任务的逻辑代码。
在Application类中，通过@Autowired注入DynamicTaskConfig对象，并使用其中的方法来操作定时任务的添加、删除、修改、启动和停止。
