上传备份

src/main/java/xyz/wbsite/jmacro/JMainService.java

@@ -1,7 +1,6 @@
 package xyz.wbsite.jmacro;
 
 import cn.hutool.core.collection.CollUtil;
-import org.jobrunr.jobs.lambdas.JobLambda;
 import xyz.wbsite.jmacro.base.Legend;
 import xyz.wbsite.jmacro.util.DialogUtil;
 import xyz.wbsite.jmacro.util.Logger;

src/main/java/xyz/wbsite/jmacro/JScheduler.java

@@ -3,9 +3,13 @@ package xyz.wbsite.jmacro;
 import java.time.LocalTime;
 import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.Queue;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ConcurrentSkipListSet;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
@@ -31,88 +35,108 @@ public class JScheduler {
     /**
      * 任务映射表，用于存储任务ID和对应的 ScheduledFuture<?> 对象
      */
-    private final Map<String, ScheduledFuture<?>> tasks = new ConcurrentHashMap<>();
+    private final Queue<ScheduledFuture<?>> tasksHolder = new ConcurrentLinkedQueue<>();
 
     private static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("HH:mm:ss");
 
     /**
-     * 添加固定延迟循环任务（无限）
+     * 添加固定延迟循环任务
      *
-     * @param taskId       任务ID
      * @param task            任务
-     * @param initialDelay 初始延迟
+     * @param intervalSeconds 周期（单位秒）
-     * @param delay        延迟
-     * @param unit         时间单位
      */
-    public void scheduleFixedDelay(String taskId, Runnable task, long initialDelay, long delay, TimeUnit unit) {
+    public void schedule(Runnable task, long intervalSeconds) {
-        cancelTask(taskId);
+        ScheduledFuture<?> future = executor.scheduleWithFixedDelay(task, 0, intervalSeconds, TimeUnit.SECONDS);
-        ScheduledFuture<?> future = executor.scheduleWithFixedDelay(task, initialDelay, delay, unit);
+        tasksHolder.add(future);
-        tasks.put(taskId, future);
     }
 
     /**
      * 添加固定次数循环任务
      *
-     * @param taskId       任务ID
      * @param task            任务
-     * @param initialDelay 初始延迟
+     * @param intervalSeconds 周期（单位秒）
-     * @param period       周期
-     * @param unit         时间单位
      * @param times           执行次数
      */
-    public void scheduleFixedTimes(String taskId, Runnable task, long initialDelay, long period, TimeUnit unit, int times) {
+    public void schedule(Runnable task, long intervalSeconds, int times) {
-        cancelTask(taskId);
+        ScheduledFuture<?> future = executor.scheduleWithFixedDelay(new LimitedTask(task, times), 0, intervalSeconds, TimeUnit.SECONDS);
-        ScheduledFuture<?> future = executor.scheduleWithFixedDelay(new LimitedTask(task, times), initialDelay, period, unit);
+        tasksHolder.add(future);
-        tasks.put(taskId, future);
     }
 
+
+    private final Map<Runnable, ConcurrentSkipListSet<Integer>> taskTimeMap = new ConcurrentHashMap<>();
+
     /**
-     * 添加多时间点任务（例如 "08:30:00,12:00:00,18:00:00"）
+     * 添加单时间点任务
      *
-     * @param taskId     任务ID
+     * @param task
-     * @param task       任务
+     * @param time
-     * @param timePoints 时间点字符串（逗号分隔）
      */
-    public void scheduleAtTimes(String taskId, Runnable task, String timePoints) {
+    public void schedule(Runnable task, String time) {
-        cancelTask(taskId);
+        schedule(task, Arrays.asList(time.split(",")));
+    }
 
-        List<LocalTime> times = parseTimePoints(timePoints);
+    /**
-        if (times.isEmpty()) return;
+     * 添加多时间点任务
+     * <p>
+     * 例如 "08:30:00"
+     *
+     * @param task 任务
+     * @param time 时间点
+     */
+    public void schedule(Runnable task, List<String> time) {
+        if (time.isEmpty()) {
+            return;
+        }
 
-        Runnable timeChecker = () -> {
+        // 转换为数字集合（秒级精度）
-            LocalTime now = LocalTime.now();
+        ConcurrentSkipListSet<Integer> timeSet = new ConcurrentSkipListSet<>();
-            for (LocalTime scheduledTime : times) {
+        Runnable trigger = () -> {
-                if (isSameTime(now, scheduledTime)) {
+            for (String string : time) {
-                    task.run();
+                int nowSeconds = LocalTime.now().toSecondOfDay();
+                int secondOfDay = LocalTime.parse(string, TIME_FORMATTER).toSecondOfDay();
+                if (secondOfDay < nowSeconds) {
+                    continue;
                 }
+                timeSet.add(secondOfDay);
             }
         };
-
+        trigger.run();
-        // 每秒检查一次
+        // 修正时间计算：计算到下一个凌晨的秒数
-        ScheduledFuture<?> future = executor.scheduleAtFixedRate(timeChecker, 0, 1, TimeUnit.SECONDS);
+        long nowSeconds = LocalTime.now().toSecondOfDay();
-        tasks.put(taskId, future);
+        // 剩余秒数到次日凌晨
+        long delay = (24 * 3600 - nowSeconds) % (24 * 3600);
+
+        // 使用 scheduleAtFixedRate 保证每日执行
+        ScheduledFuture<?> triggerFuture = executor.scheduleAtFixedRate(
+                trigger,
+                delay,
+                24 * 3600,  // 24小时周期
+                TimeUnit.SECONDS
+        );
+        tasksHolder.add(triggerFuture);
+
+        // 创建每秒检查的任务
+        Runnable checker = () -> {
+            int now = LocalTime.now().toSecondOfDay();
+            Integer nextTime = timeSet.floor(now);
+            if (nextTime != null) {
+                task.run();
+                timeSet.remove(nextTime);
             }
+        };
 
-    /**
+        ScheduledFuture<?> checkerFuture = executor.scheduleAtFixedRate(checker, 0, 1, TimeUnit.SECONDS);
-     * 取消所有任务
+        tasksHolder.add(checkerFuture);
-     */
-    public void cancelAllTask() {
-        for (ScheduledFuture<?> future : tasks.values()) {
-            future.cancel(false);
-        }
-        tasks.clear();
     }
 
     /**
-     * 取消指定任务
+     * 取消任务
-     *
-     * @param taskId 任务ID
      */
-    public void cancelTask(String taskId) {
+    public void cancel() {
-        ScheduledFuture<?> future = tasks.remove(taskId);
+        for (ScheduledFuture<?> future : tasksHolder) {
-        if (future != null) {
             future.cancel(false);
         }
+        tasksHolder.clear();
     }
 
     /**
@@ -130,7 +154,9 @@ public class JScheduler {
      */
     private List<LocalTime> parseTimePoints(String timePoints) {
         List<LocalTime> result = new ArrayList<>();
-        if (timePoints == null || timePoints.trim().isEmpty()) return result;
+        if (timePoints == null || timePoints.trim().isEmpty()) {
+            return result;
+        }
 
         String[] parts = timePoints.split(",");
         for (String part : parts) {
@@ -143,19 +169,6 @@ public class JScheduler {
         return result;
     }
 
-    /**
-     * 判断两个时间是否相同（忽略毫秒）
-     *
-     * @param t1 时间1
-     * @param t2 时间2
-     * @return 是否相同
-     */
-    private boolean isSameTime(LocalTime t1, LocalTime t2) {
-        return t1.getHour() == t2.getHour() &&
-                t1.getMinute() == t2.getMinute() &&
-                t1.getSecond() == t2.getSecond();
-    }
-
     /**
      * 有限次数任务包装器
      */
@@ -175,9 +188,9 @@ public class JScheduler {
                 remainingTimes--;
                 if (remainingTimes == 0) {
                     // 任务执行完毕，取消自己
-                    for (Map.Entry<String, ScheduledFuture<?>> entry : tasks.entrySet()) {
+                    for (ScheduledFuture<?> future : tasksHolder) {
-                        if (entry.getValue().isDone()) {
+                        if (future.isDone()) {
-                            tasks.remove(entry.getKey());
+                            tasksHolder.remove(future);
                         }
                     }
                 }
@@ -189,28 +202,27 @@ public class JScheduler {
         JScheduler scheduler = new JScheduler();
 
         // 1. 无限循环任务（每2秒执行一次）
-        scheduler.scheduleFixedDelay("task1",
+//        scheduler.schedule(() -> System.out.println("无限任务执行: " + LocalTime.now()),
-                () -> System.out.println("无限任务执行: " + LocalTime.now()),
+//                2);
-                0, 2, TimeUnit.SECONDS);
+
-
+//        // 2. 有限次数任务（执行5次，每1秒一次）
-        // 2. 有限次数任务（执行5次，每1秒一次）
+//        scheduler.schedule(
-        scheduler.scheduleFixedTimes("task2",
+//                () -> System.out.println("有限任务执行: " + LocalTime.now()),
-                () -> System.out.println("有限任务执行: " + LocalTime.now()),
+//                3, 5);
-                0, 1, TimeUnit.SECONDS, 5);
+//
-
+//        // 3. 多时间点任务（每天 08:30:00, 12:00:00, 18:00:00 执行）
-        // 3. 多时间点任务（每天 08:30:00, 12:00:00, 18:00:00 执行）
+        scheduler.schedule(
-        scheduler.scheduleAtTimes("task3",
                 () -> System.out.println("定时任务执行: " + LocalTime.now()),
-                "08:30:00,12:00:00,18:00:00");
+                "12:58:00,18:00:00");
 
         // 运行一段时间后关闭
         try {
-            Thread.sleep(10_000);
+            Thread.sleep(60_000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 
-        scheduler.cancelAllTask();
+        scheduler.cancel();
 
         scheduler.shutdown();
     }