如何在 ScheduledExecutorService 中实现任务的动态调度

在 Java 中，ScheduledExecutorService 是一个用于执行定时任务和周期性任务的接口。要实现任务的动态调度，你可以在运行时根据需要添加、修改或删除任务。以下是一个简单的示例，展示了如何使用 ScheduledExecutorService 实现任务的动态调度：

1. 首先，创建一个 ScheduledExecutorService 实例：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;

public class DynamicScheduler {
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(4);

    // 其他代码...
}

2. 创建一个任务类，实现 Runnable 接口：

public class MyTask implements Runnable {
    private final String name;

    public MyTask(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println("Task " + name + " is running at " + LocalDateTime.now());
    }
}

3. 在 DynamicScheduler 类中添加方法以动态调度任务：

import java.time.LocalDateTime;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;

public class DynamicScheduler {
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(4);
    private final Map<String, ScheduledFuture<?>> tasks = new ConcurrentHashMap<>();

    public void scheduleTask(String taskId, MyTask task, long initialDelay, long period, TimeUnit unit) {
        ScheduledFuture<?> scheduledTask = scheduler.scheduleAtFixedRate(task, initialDelay, period, unit);
        tasks.put(taskId, scheduledTask);
    }

    public void cancelTask(String taskId) {
        ScheduledFuture<?> scheduledTask = tasks.get(taskId);
        if (scheduledTask != null) {
            scheduledTask.cancel(false);
            tasks.remove(taskId);
        }
    }

    public void rescheduleTask(String taskId, long newInitialDelay, long newPeriod, TimeUnit unit) {
        cancelTask(taskId);
        scheduleTask(taskId, new MyTask(taskId), newInitialDelay, newPeriod, unit);
    }

    // 其他代码...
}

在这个示例中，我们使用一个 ConcurrentHashMap 来存储任务 ID 和对应的 ScheduledFuture 对象。这样我们可以在运行时根据任务 ID 查找、取消或重新调度任务。

4. 使用 DynamicScheduler 类动态调度任务：

public class Main {
    public static void main(String[] args) {
        DynamicScheduler scheduler = new DynamicScheduler();

        MyTask task1 = new MyTask("Task1");
        scheduler.scheduleTask("Task1", task1, 0, 2, TimeUnit.SECONDS);

        MyTask task2 = new MyTask("Task2");
        scheduler.scheduleTask("Task2", task2, 1, 3, TimeUnit.SECONDS);

        // 在 5 秒后取消 Task1
        scheduler.scheduleTask("cancelTask1", () -> scheduler.cancelTask("Task1"), 5, 1, TimeUnit.SECONDS);

        // 在 10 秒后重新调度 Task2，初始延迟变为 0，周期变为 1 秒
        scheduler.scheduleTask("rescheduleTask2", () -> scheduler.rescheduleTask("Task2", 0, 1, TimeUnit.SECONDS), 10, 1, TimeUnit.SECONDS);
    }
}

这个示例中，我们创建了两个任务（Task1 和 Task2），并使用 DynamicScheduler 类动态调度它们。我们还添加了两个额外的任务，用于在 5 秒后取消 Task1，以及在 10 秒后重新调度 Task2。