Add new scheduler, refactor scheduler system

Rename the old ScheduledTaskThreadPool class to
EDFSchedulerThreadPool and remove its deprecation.

Move important scheduling methods to the new abstract Scheduler
class.
Move the schedulable tick abstraction to its own class, SchedulableTick.

Move DEADLINE_NOT_SET to TimeUtil, where it really should have been
in the first place.

Add a simple interface, OSNuma, to interact with the OS's NUMA and
affinity APIs. It looks like Linux will be the only supported
platform (provided libnuma is installed), as the Windows API
for this is atrocious.
This change makes use of JNA as a new dependency.

Add a new work stealing scheduler which, unlike the EDF scheduler,
supports NUMA aware scheduling, intermediate task execution,
and dynamic thread adjustment.

Author: Spottedleaf

.github/workflows/build.yml

@@ -12,7 +12,7 @@ jobs:
     if: ${{ github.event_name != 'pull_request' || github.repository != github.event.pull_request.head.repo.full_name }}
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: "jdk"
         uses: actions/setup-java@v5
         with:

build.gradle.kts

@@ -11,6 +11,7 @@ repositories {
 dependencies {
     implementation(libs.org.slf4j.slf4j.api)
     implementation(libs.it.unimi.dsi.fastutil)
+    implementation(libs.net.java.dev.jna)
 }
 
 tasks.jar {

gradle/libs.versions.toml

@@ -1,7 +1,9 @@
 [versions]
 it-unimi-dsi-fastutil = "8.5.15"
 org-slf4j-slf4j-api = "2.0.17"
+net-java-dev-jna = "5.17.0"
 
 [libraries]
 it-unimi-dsi-fastutil = { module = "it.unimi.dsi:fastutil", version.ref = "it-unimi-dsi-fastutil" }
 org-slf4j-slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "org-slf4j-slf4j-api" }
+net-java-dev-jna = { module = "net.java.dev.jna:jna", version.ref = "net-java-dev-jna" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

src/main/java/ca/spottedleaf/concurrentutil/executor/thread/BalancedPrioritisedThreadPool.java

@@ -7,9 +7,11 @@
 import ca.spottedleaf.concurrentutil.util.TimeUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
 
@@ -19,23 +21,22 @@ public final class BalancedPrioritisedThreadPool {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(BalancedPrioritisedThreadPool.class);
 
-    private final Consumer<Thread> threadModifier;
-
     private final COWArrayList<OrderedStreamGroup> groups = new COWArrayList<>(OrderedStreamGroup.class);
     private final COWArrayList<WorkerThread> threads = new COWArrayList<>(WorkerThread.class);
     private final COWArrayList<WorkerThread> aliveThreads = new COWArrayList<>(WorkerThread.class);
 
     private final long groupTimeSliceNS;
+    private final Consumer<Thread> threadModifier;
 
     private boolean shutdown;
 
     public BalancedPrioritisedThreadPool(final long groupTimeSliceNS, final Consumer<Thread> threadModifier) {
+        this.groupTimeSliceNS = groupTimeSliceNS;
         this.threadModifier = threadModifier;
 
         if (threadModifier == null) {
             throw new NullPointerException("Thread factory may not be null");
         }
-        this.groupTimeSliceNS = groupTimeSliceNS;
     }
 
     private void wakeupIdleThread() {
@@ -103,20 +104,29 @@ public boolean joinInterruptable(final long msToWait) throws InterruptedExceptio
     }
 
     private boolean join(final long msToWait, final boolean interruptable) throws InterruptedException {
-        final long nsToWait = msToWait * (1000 * 1000);
+        synchronized (this) {
+            if (!this.shutdown) {
+                throw new IllegalStateException("Attempting to join on non-shutdown pool");
+            }
+        }
+
+        final long nsToWait = TimeUnit.MILLISECONDS.toNanos(msToWait);
         final long start = System.nanoTime();
         final long deadline = start + nsToWait;
         boolean interrupted = false;
         try {
             for (final WorkerThread thread : this.aliveThreads.getArray()) {
                 while (thread.isAlive()) {
-                    final long current = System.nanoTime();
-                    if (current - deadline >= 0L && msToWait > 0L) {
-                        return false;
-                    }
-
                     try {
-                        thread.join(msToWait <= 0L ? 0L : Math.max(1L, (deadline - current) / (1000 * 1000)));
+                        if (msToWait > 0L) {
+                            final long current = System.nanoTime();
+                            if (current - deadline >= 0L) {
+                                return false;
+                            }
+                            thread.join(Duration.ofNanos(deadline - current));
+                        } else {
+                            thread.join();
+                        }
                     } catch (final InterruptedException ex) {
                         if (interruptable) {
                             throw ex;

src/main/java/ca/spottedleaf/concurrentutil/executor/thread/StreamOrderedThreadPool.java

@@ -15,6 +15,21 @@ public E[] getArray() {
         return this.array;
     }
 
+    public void clear() {
+        synchronized (this) {
+            this.array = Arrays.copyOf(this.array, 0);
+        }
+    }
+
+    public void set(final E[] array) {
+        if (array.getClass() != this.array.getClass()) {
+            throw new IllegalStateException();
+        }
+        synchronized (this) {
+            this.array = array;
+        }
+    }
+
     public boolean contains(final E test) {
         for (final E elem : this.array) {
             if (elem == test) {