Refactor CoreScheduler and ScheduledTask to remove Bukkit dependencies and implement a standalone, thread-safe scheduling system

Author: mzcydev

src/main/java/gg/nextforge/scheduler/CoreScheduler.java

@@ -1,220 +1,94 @@
 package gg.nextforge.scheduler;
 
 import lombok.Getter;
-import org.bukkit.Bukkit;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.scheduler.BukkitTask;
 
-import java.util.Collection;
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**
- * A wrapper around Bukkit's scheduler to simplify task management.
- * <p>
- * Features:
- * - Static access for convenience (e.g., CoreScheduler.runLater())
- * - Automatic task cleanup
- * - Cancel tokens for better task control
- * - Avoids manual tracking of task IDs
+ * A standalone, thread-safe scheduler implementation.
+ * No Bukkit dependencies, suitable for general Java use.
  */
 public class CoreScheduler {
 
-    private static CoreScheduler instance; // Singleton instance of CoreScheduler
-    private final Plugin plugin; // Plugin instance for scheduling tasks
+    private static CoreScheduler instance;
+
     @Getter
-    private static final Map<Integer, ScheduledTask> activeTasks = new ConcurrentHashMap<>(); // Active tasks map
-    private final AtomicInteger taskCounter = new AtomicInteger(0); // Counter for task IDs
-
-    /**
-     * Constructs a CoreScheduler instance.
-     *
-     * @param plugin The plugin instance.
-     */
-    public CoreScheduler(Plugin plugin) {
-        this.plugin = plugin;
+    private static final Map<Integer, ScheduledTask> activeTasks = new ConcurrentHashMap<>();
+
+    private final ScheduledExecutorService executorService;
+    private final AtomicInteger taskCounter = new AtomicInteger(0);
+
+    public CoreScheduler() {
+        this.executorService = Executors.newScheduledThreadPool(Runtime.getRuntime().availableProcessors());
         instance = this;
     }
 
-    /**
-     * Runs a task on the next tick.
-     *
-     * @param task The task to run.
-     * @return A ScheduledTask representing the scheduled task.
-     */
     public static ScheduledTask run(Runnable task) {
-        return instance.runTask(task);
+        return instance.schedule(task, 0, false, false);
     }
 
-    // Static convenience methods for scheduling tasks
-
-    /**
-     * Runs a task after a specified delay.
-     *
-     * @param task  The task to run.
-     * @param delay The delay in ticks (20 ticks = 1 second).
-     * @return A ScheduledTask representing the scheduled task.
-     */
-    public static ScheduledTask runLater(Runnable task, long delay) {
-        return instance.runTaskLater(task, delay);
+    public static ScheduledTask runLater(Runnable task, long delayTicks) {
+        return instance.schedule(task, delayTicks, false, false);
     }
 
-    /**
-     * Runs a task repeatedly with a specified delay and interval.
-     *
-     * @param task   The task to run.
-     * @param delay  The initial delay in ticks.
-     * @param period The interval between executions in ticks.
-     * @return A ScheduledTask representing the scheduled task.
-     */
-    public static ScheduledTask runTimer(Runnable task, long delay, long period) {
-        return instance.runTaskTimer(task, delay, period);
+    public static ScheduledTask runTimer(Runnable task, long delayTicks, long periodTicks) {
+        return instance.scheduleRepeating(task, delayTicks, periodTicks, false);
     }
 
-    /**
-     * Runs a task asynchronously.
-     *
-     * @param task The task to run.
-     * @return A ScheduledTask representing the scheduled task.
-     */
     public static ScheduledTask runAsync(Runnable task) {
-        return instance.runTaskAsync(task);
+        return instance.schedule(task, 0, true, false);
     }
 
-    /**
-     * Runs a task asynchronously after a specified delay.
-     *
-     * @param task  The task to run.
-     * @param delay The delay in ticks.
-     * @return A ScheduledTask representing the scheduled task.
-     */
-    public static ScheduledTask runAsyncLater(Runnable task, long delay) {
-        return instance.runTaskAsyncLater(task, delay);
+    public static ScheduledTask runAsyncLater(Runnable task, long delayTicks) {
+        return instance.schedule(task, delayTicks, true, false);
     }
 
-    /**
-     * Runs a task asynchronously and repeatedly.
-     *
-     * @param task   The task to run.
-     * @param delay  The initial delay in ticks.
-     * @param period The interval between executions in ticks.
-     * @return A ScheduledTask representing the scheduled task.
-     */
-    public static ScheduledTask runAsyncTimer(Runnable task, long delay, long period) {
-        return instance.runTaskAsyncTimer(task, delay, period);
+    public static ScheduledTask runAsyncTimer(Runnable task, long delayTicks, long periodTicks) {
+        return instance.scheduleRepeating(task, delayTicks, periodTicks, true);
     }
 
-    /**
-     * Cleans up all active tasks.
-     * Should be called when the plugin is disabled.
-     */
     public void shutdown() {
         activeTasks.values().forEach(ScheduledTask::cancel);
         activeTasks.clear();
+        executorService.shutdownNow();
     }
 
-    // Instance methods for scheduling tasks
-
-    private ScheduledTask runTask(Runnable task) {
-        int id = taskCounter.incrementAndGet();
-        ScheduledTask scheduled = new ScheduledTask(id);
-
-        BukkitTask bukkitTask = Bukkit.getScheduler().runTask(plugin, () -> {
-            try {
-                task.run();
-            } finally {
-                activeTasks.remove(id);
-            }
-        });
-
-        scheduled.setBukkitTask(bukkitTask);
-        activeTasks.put(id, scheduled);
-        return scheduled;
-    }
-
-    private ScheduledTask runTaskLater(Runnable task, long delay) {
-        int id = taskCounter.incrementAndGet();
-        ScheduledTask scheduled = new ScheduledTask(id);
-
-        BukkitTask bukkitTask = Bukkit.getScheduler().runTaskLater(plugin, () -> {
-            try {
-                task.run();
-            } finally {
-                activeTasks.remove(id);
-            }
-        }, delay);
-
-        scheduled.setBukkitTask(bukkitTask);
-        activeTasks.put(id, scheduled);
-        return scheduled;
-    }
-
-    private ScheduledTask runTaskTimer(Runnable task, long delay, long period) {
-        int id = taskCounter.incrementAndGet();
-        ScheduledTask scheduled = new ScheduledTask(id);
-
-        BukkitTask bukkitTask = Bukkit.getScheduler().runTaskTimer(plugin, task, delay, period);
-
-        scheduled.setBukkitTask(bukkitTask);
-        activeTasks.put(id, scheduled);
-        return scheduled;
-    }
-
-    private ScheduledTask runTaskAsync(Runnable task) {
-        int id = taskCounter.incrementAndGet();
-        ScheduledTask scheduled = new ScheduledTask(id);
-
-        BukkitTask bukkitTask = Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
-            try {
-                task.run();
-            } finally {
-                activeTasks.remove(id);
-            }
-        });
-
-        scheduled.setBukkitTask(bukkitTask);
-        activeTasks.put(id, scheduled);
-        return scheduled;
-    }
-
-    private ScheduledTask runTaskAsyncLater(Runnable task, long delay) {
+    private ScheduledTask schedule(Runnable task, long delayTicks, boolean async, boolean repeating) {
         int id = taskCounter.incrementAndGet();
-        ScheduledTask scheduled = new ScheduledTask(id);
+        ScheduledTask scheduledTask = new ScheduledTask(id);
+        long delayMillis = ticksToMillis(delayTicks);
 
-        BukkitTask bukkitTask = Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, () -> {
+        ScheduledFuture<?> future = executorService.schedule(() -> {
             try {
                 task.run();
             } finally {
-                activeTasks.remove(id);
+                if (!repeating) {
+                    activeTasks.remove(id);
+                }
             }
-        }, delay);
+        }, delayMillis, TimeUnit.MILLISECONDS);
 
-        scheduled.setBukkitTask(bukkitTask);
-        activeTasks.put(id, scheduled);
-        return scheduled;
+        scheduledTask.setFuture(future);
+        activeTasks.put(id, scheduledTask);
+        return scheduledTask;
     }
 
-    private ScheduledTask runTaskAsyncTimer(Runnable task, long delay, long period) {
+    private ScheduledTask scheduleRepeating(Runnable task, long delayTicks, long periodTicks, boolean async) {
         int id = taskCounter.incrementAndGet();
-        ScheduledTask scheduled = new ScheduledTask(id);
+        ScheduledTask scheduledTask = new ScheduledTask(id);
+        long delayMillis = ticksToMillis(delayTicks);
+        long periodMillis = ticksToMillis(periodTicks);
 
-        BukkitTask bukkitTask = Bukkit.getScheduler().runTaskTimerAsynchronously(
-                plugin, task, delay, period
-        );
+        ScheduledFuture<?> future = executorService.scheduleAtFixedRate(task, delayMillis, periodMillis, TimeUnit.MILLISECONDS);
 
-        scheduled.setBukkitTask(bukkitTask);
-        activeTasks.put(id, scheduled);
-        return scheduled;
+        scheduledTask.setFuture(future);
+        activeTasks.put(id, scheduledTask);
+        return scheduledTask;
     }
 
-    /**
-     * Runs a task on the main thread.
-     * Useful for accessing Bukkit API from asynchronous tasks.
-     *
-     * @param task The task to run.
-     */
-    public void runSync(Runnable task) {
-        Bukkit.getScheduler().runTask(plugin, task);
+    private long ticksToMillis(long ticks) {
+        return ticks * 50L; // 20 ticks = 1 second
     }
-}
+}

src/main/java/gg/nextforge/scheduler/ScheduledTask.java

@@ -1,62 +1,25 @@
 package gg.nextforge.scheduler;
 
-import org.bukkit.Bukkit;
-import org.bukkit.scheduler.BukkitTask;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.concurrent.ScheduledFuture;
 
-/**
- * Represents a scheduled task that can be cancelled.
- */
 public class ScheduledTask {
-    private final int id; // Unique ID for the task
-    private BukkitTask bukkitTask; // Bukkit task instance
-    private volatile boolean cancelled = false; // Flag indicating if the task is cancelled
 
-    /**
-     * Constructs a ScheduledTask instance.
-     *
-     * @param id The unique ID for the task.
-     */
-    ScheduledTask(int id) {
-        this.id = id;
-    }
+    @Getter
+    private final int id;
 
-    /**
-     * Sets the BukkitTask instance for this ScheduledTask.
-     *
-     * @param task The BukkitTask instance.
-     */
-    void setBukkitTask(BukkitTask task) {
-        this.bukkitTask = task;
+    @Setter
+    private ScheduledFuture<?> future;
+
+    public ScheduledTask(int id) {
+        this.id = id;
     }
 
-    /**
-     * Cancels this task.
-     * Can be called multiple times safely.
-     */
     public void cancel() {
-        if (!cancelled && bukkitTask != null) {
-            bukkitTask.cancel();
-            cancelled = true;
-            CoreScheduler.getActiveTasks().remove(id);
+        if (future != null) {
+            future.cancel(false);
         }
     }
-
-    /**
-     * Checks if this task is still active.
-     *
-     * @return True if the task is running, false otherwise.
-     */
-    public boolean isActive() {
-        return !cancelled && bukkitTask != null &&
-                Bukkit.getScheduler().isCurrentlyRunning(bukkitTask.getTaskId());
-    }
-
-    /**
-     * Retrieves the task ID of this ScheduledTask.
-     *
-     * @return The task ID, or -1 if the task is not active.
-     */
-    public int getTaskId() {
-        return bukkitTask != null ? bukkitTask.getTaskId() : -1;
-    }
 }