From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Spottedleaf <Spottedleaf@users.noreply.github.com>
Date: Mon, 21 Oct 2024 11:47:34 -0700
Subject: [PATCH] fixup! ConcurrentUtil


diff --git a/src/main/java/ca/spottedleaf/concurrentutil/collection/SRSWLinkedQueue.java b/src/main/java/ca/spottedleaf/concurrentutil/collection/SRSWLinkedQueue.java
deleted file mode 100644
index 094eff418b4e3bffce020d650931b4d9e58fa9ed..0000000000000000000000000000000000000000
--- a/src/main/java/ca/spottedleaf/concurrentutil/collection/SRSWLinkedQueue.java
+++ /dev/null
@@ -1,149 +0,0 @@
-package ca.spottedleaf.concurrentutil.collection;
-
-import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
-import ca.spottedleaf.concurrentutil.util.Validate;
-
-import java.lang.invoke.VarHandle;
-import java.util.ConcurrentModificationException;
-
-/**
- * Single reader thread single writer thread queue. The reader side of the queue is ordered by acquire semantics,
- * and the writer side of the queue is ordered by release semantics.
- */
-// TODO test
-public class SRSWLinkedQueue<E> {
-
-    // always non-null
-    protected LinkedNode<E> head;
-
-    // always non-null
-    protected LinkedNode<E> tail;
-
-    /* IMPL NOTE: Leave hashCode and equals to their defaults */
-
-    public SRSWLinkedQueue() {
-        final LinkedNode<E> dummy = new LinkedNode<>(null, null);
-        this.head = this.tail = dummy;
-    }
-
-    /**
-     * Must be the reader thread.
-     *
-     * <p>
-     * Returns, without removing, the first element of this queue.
-     * </p>
-     * @return Returns, without removing, the first element of this queue.
-     */
-    public E peekFirst() {
-        LinkedNode<E> head = this.head;
-        E ret = head.getElementPlain();
-        if (ret == null) {
-            head = head.getNextAcquire();
-            if (head == null) {
-                // empty
-                return null;
-            }
-            // update head reference for next poll() call
-            this.head = head;
-            // guaranteed to be non-null
-            ret = head.getElementPlain();
-            if (ret == null) {
-                throw new ConcurrentModificationException("Multiple reader threads");
-            }
-        }
-
-        return ret;
-    }
-
-    /**
-     * Must be the reader thread.
-     *
-     * <p>
-     * Returns and removes the first element of this queue.
-     * </p>
-     * @return Returns and removes the first element of this queue.
-     */
-    public E poll() {
-        LinkedNode<E> head = this.head;
-        E ret = head.getElementPlain();
-        if (ret == null) {
-            head = head.getNextAcquire();
-            if (head == null) {
-                // empty
-                return null;
-            }
-            // guaranteed to be non-null
-            ret = head.getElementPlain();
-            if (ret == null) {
-                throw new ConcurrentModificationException("Multiple reader threads");
-            }
-        }
-
-        head.setElementPlain(null);
-        LinkedNode<E> next = head.getNextAcquire();
-        this.head = next == null ? head : next;
-
-        return ret;
-    }
-
-    /**
-     * Must be the writer thread.
-     *
-     * <p>
-     * Adds the element to the end of the queue.
-     * </p>
-     *
-     * @throws NullPointerException If the provided element is null
-     */
-    public void addLast(final E element) {
-        Validate.notNull(element, "Provided element cannot be null");
-        final LinkedNode<E> append = new LinkedNode<>(element, null);
-
-        this.tail.setNextRelease(append);
-        this.tail = append;
-    }
-
-    protected static final class LinkedNode<E> {
-
-        protected volatile Object element;
-        protected volatile LinkedNode<E> next;
-
-        protected static final VarHandle ELEMENT_HANDLE = ConcurrentUtil.getVarHandle(LinkedNode.class, "element", Object.class);
-        protected static final VarHandle NEXT_HANDLE = ConcurrentUtil.getVarHandle(LinkedNode.class, "next", LinkedNode.class);
-
-        protected LinkedNode(final Object element, final LinkedNode<E> next) {
-            ELEMENT_HANDLE.set(this, element);
-            NEXT_HANDLE.set(this, next);
-        }
-
-        /* element */
-
-        @SuppressWarnings("unchecked")
-        protected final E getElementPlain() {
-            return (E)ELEMENT_HANDLE.get(this);
-        }
-
-        protected final void setElementPlain(final E update) {
-            ELEMENT_HANDLE.set(this, (Object)update);
-        }
-        /* next */
-
-        @SuppressWarnings("unchecked")
-        protected final LinkedNode<E> getNextPlain() {
-            return (LinkedNode<E>)NEXT_HANDLE.get(this);
-        }
-
-        @SuppressWarnings("unchecked")
-        protected final LinkedNode<E> getNextAcquire() {
-            return (LinkedNode<E>)NEXT_HANDLE.getAcquire(this);
-        }
-
-        protected final void setNextPlain(final LinkedNode<E> next) {
-            NEXT_HANDLE.set(this, next);
-        }
-
-        protected final void setNextRelease(final LinkedNode<E> next) {
-            NEXT_HANDLE.setRelease(this, next);
-        }
-    }
-}
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/completable/CallbackCompletable.java b/src/main/java/ca/spottedleaf/concurrentutil/completable/CallbackCompletable.java
new file mode 100644
index 0000000000000000000000000000000000000000..6bad6f8ecc0944d2f406924c7de7e227ff1e70fa
--- /dev/null
+++ b/src/main/java/ca/spottedleaf/concurrentutil/completable/CallbackCompletable.java
@@ -0,0 +1,110 @@
+package ca.spottedleaf.concurrentutil.completable;
+
+import ca.spottedleaf.concurrentutil.collection.MultiThreadedQueue;
+import ca.spottedleaf.concurrentutil.executor.Cancellable;
+import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import java.util.function.BiConsumer;
+
+public final class CallbackCompletable<T> {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(CallbackCompletable.class);
+
+    private final MultiThreadedQueue<BiConsumer<T, Throwable>> waiters = new MultiThreadedQueue<>();
+    private T result;
+    private Throwable throwable;
+    private volatile boolean completed;
+
+    public boolean isCompleted() {
+        return this.completed;
+    }
+
+    /**
+     * Note: Can only use after calling {@link #addAsynchronousWaiter(BiConsumer)}, as this function performs zero
+     * synchronisation
+     */
+    public T getResult() {
+        return this.result;
+    }
+
+    /**
+     * Note: Can only use after calling {@link #addAsynchronousWaiter(BiConsumer)}, as this function performs zero
+     * synchronisation
+     */
+    public Throwable getThrowable() {
+        return this.throwable;
+    }
+
+    /**
+     * Adds a waiter that should only be completed asynchronously by the complete() calls. If complete()
+     * has already been called, returns {@code null} and does not invoke the specified consumer.
+     * @param consumer Consumer to be executed on completion
+     * @throws NullPointerException If consumer is null
+     * @return A cancellable which will control the execution of the specified consumer
+     */
+    public Cancellable addAsynchronousWaiter(final BiConsumer<T, Throwable> consumer) {
+        if (this.waiters.add(consumer)) {
+            return new CancellableImpl(consumer);
+        }
+        return null;
+    }
+
+    private void completeAllWaiters(final T result, final Throwable throwable) {
+        this.completed = true;
+        BiConsumer<T, Throwable> waiter;
+        while ((waiter = this.waiters.pollOrBlockAdds()) != null) {
+            this.completeWaiter(waiter, result, throwable);
+        }
+    }
+
+    private void completeWaiter(final BiConsumer<T, Throwable> consumer, final T result, final Throwable throwable) {
+        try {
+            consumer.accept(result, throwable);
+        } catch (final Throwable throwable2) {
+            LOGGER.error("Failed to complete callback " + ConcurrentUtil.genericToString(consumer), throwable2);
+        }
+    }
+
+    /**
+     * Adds a waiter that will be completed asynchronously by the complete() calls. If complete()
+     * has already been called, then invokes the consumer synchronously with the completed result.
+     * @param consumer Consumer to be executed on completion
+     * @throws NullPointerException If consumer is null
+     * @return A cancellable which will control the execution of the specified consumer
+     */
+    public Cancellable addWaiter(final BiConsumer<T, Throwable> consumer) {
+        if (this.waiters.add(consumer)) {
+            return new CancellableImpl(consumer);
+        }
+        this.completeWaiter(consumer, this.result, this.throwable);
+        return new CancellableImpl(consumer);
+    }
+
+    public void complete(final T result) {
+        this.result = result;
+        this.completeAllWaiters(result, null);
+    }
+
+    public void completeWithThrowable(final Throwable throwable) {
+        if (throwable == null) {
+            throw new NullPointerException("Throwable cannot be null");
+        }
+        this.throwable = throwable;
+        this.completeAllWaiters(null, throwable);
+    }
+
+    private final class CancellableImpl implements Cancellable {
+
+        private final BiConsumer<T, Throwable> waiter;
+
+        private CancellableImpl(final BiConsumer<T, Throwable> waiter) {
+            this.waiter = waiter;
+        }
+
+        @Override
+        public boolean cancel() {
+            return CallbackCompletable.this.waiters.remove(this.waiter);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/completable/Completable.java b/src/main/java/ca/spottedleaf/concurrentutil/completable/Completable.java
index 46d1bd01542ebeeffc0006a5c585a50dbbbff907..365616439fa079017d648ed7f6ddf6950a691adf 100644
--- a/src/main/java/ca/spottedleaf/concurrentutil/completable/Completable.java
+++ b/src/main/java/ca/spottedleaf/concurrentutil/completable/Completable.java
@@ -1,112 +1,737 @@
 package ca.spottedleaf.concurrentutil.completable;
 
-import ca.spottedleaf.concurrentutil.collection.MultiThreadedQueue;
-import ca.spottedleaf.concurrentutil.executor.Cancellable;
 import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
+import ca.spottedleaf.concurrentutil.util.Validate;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import java.lang.invoke.VarHandle;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.locks.LockSupport;
 import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
 
 public final class Completable<T> {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(Completable.class);
+    private static final Function<? super Throwable, ? extends Throwable> DEFAULT_EXCEPTION_HANDLER = (final Throwable thr) -> {
+        LOGGER.error("Unhandled exception during Completable operation", thr);
+        return thr;
+    };
 
-    private final MultiThreadedQueue<BiConsumer<T, Throwable>> waiters = new MultiThreadedQueue<>();
-    private T result;
-    private Throwable throwable;
-    private volatile boolean completed;
+    public static Executor getDefaultExecutor() {
+        return ForkJoinPool.commonPool();
+    }
+
+    private static final Transform<?, ?> COMPLETED_STACK = new Transform<>(null, null, null, null) {
+        @Override
+        public void run() {}
+    };
+    private volatile Transform<?, T> completeStack;
+    private static final VarHandle COMPLETE_STACK_HANDLE = ConcurrentUtil.getVarHandle(Completable.class, "completeStack", Transform.class);
+
+    private static final Object NULL_MASK = new Object();
+    private volatile Object result;
+    private static final VarHandle RESULT_HANDLE = ConcurrentUtil.getVarHandle(Completable.class, "result", Object.class);
 
-    public boolean isCompleted() {
-        return this.completed;
+    private Object getResultPlain() {
+        return (Object)RESULT_HANDLE.get(this);
     }
 
-    /**
-     * Note: Can only use after calling {@link #addAsynchronousWaiter(BiConsumer)}, as this function performs zero
-     * synchronisation
-     */
-    public T getResult() {
-        return this.result;
+    private Object getResultVolatile() {
+        return (Object)RESULT_HANDLE.getVolatile(this);
     }
 
-    /**
-     * Note: Can only use after calling {@link #addAsynchronousWaiter(BiConsumer)}, as this function performs zero
-     * synchronisation
-     */
-    public Throwable getThrowable() {
-        return this.throwable;
+    private void pushStackOrRun(final Transform<?, T> push) {
+        int failures = 0;
+        for (Transform<?, T> curr = (Transform<?, T>)COMPLETE_STACK_HANDLE.getVolatile(this);;) {
+            if (curr == COMPLETED_STACK) {
+                push.execute();
+                return;
+            }
+
+            push.next = curr;
+
+            for (int i = 0; i < failures; ++i) {
+                ConcurrentUtil.backoff();
+            }
+
+            if (curr == (curr = (Transform<?, T>)COMPLETE_STACK_HANDLE.compareAndExchange(this, curr, push))) {
+                return;
+            }
+            push.next = null;
+            ++failures;
+        }
     }
 
-    /**
-     * Adds a waiter that should only be completed asynchronously by the complete() calls. If complete()
-     * has already been called, returns {@code null} and does not invoke the specified consumer.
-     * @param consumer Consumer to be executed on completion
-     * @throws NullPointerException If consumer is null
-     * @return A cancellable which will control the execution of the specified consumer
-     */
-    public Cancellable addAsynchronousWaiter(final BiConsumer<T, Throwable> consumer) {
-        if (this.waiters.add(consumer)) {
-            return new CancellableImpl(consumer);
+    private void propagateStack() {
+        Transform<?, T> topStack = (Transform<?, T>)COMPLETE_STACK_HANDLE.getAndSet(this, COMPLETED_STACK);
+        while (topStack != null) {
+            topStack.execute();
+            topStack = topStack.next;
         }
-        return null;
     }
 
-    private void completeAllWaiters(final T result, final Throwable throwable) {
-        this.completed = true;
-        BiConsumer<T, Throwable> waiter;
-        while ((waiter = this.waiters.pollOrBlockAdds()) != null) {
-            this.completeWaiter(waiter, result, throwable);
+    private static Object maskNull(final Object res) {
+        return res == null ? NULL_MASK : res;
+    }
+
+    private static Object unmaskNull(final Object res) {
+        return res == NULL_MASK ? null : res;
+    }
+
+    private static Executor checkExecutor(final Executor executor) {
+        return Validate.notNull(executor, "Executor may not be null");
+    }
+
+    public Completable() {}
+
+    private Completable(final Object complete) {
+        COMPLETE_STACK_HANDLE.set(this, COMPLETED_STACK);
+        RESULT_HANDLE.setRelease(this, complete);
+    }
+
+    public static <T> Completable<T> completed(final T value) {
+        return new Completable<>(maskNull(value));
+    }
+
+    public static <T> Completable<T> failed(final Throwable ex) {
+        Validate.notNull(ex, "Exception may not be null");
+
+        return new Completable<>(new ExceptionResult(ex));
+    }
+
+    public static <T> Completable<T> supplied(final Supplier<T> supplier) {
+        return supplied(supplier, DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public static <T> Completable<T> supplied(final Supplier<T> supplier, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+        try {
+            return completed(supplier.get());
+        } catch (final Throwable throwable) {
+            Throwable complete;
+            try {
+                complete = exceptionHandler.apply(throwable);
+            } catch (final Throwable thr2) {
+                throwable.addSuppressed(thr2);
+                complete = throwable;
+            }
+            return failed(complete);
         }
     }
 
-    private void completeWaiter(final BiConsumer<T, Throwable> consumer, final T result, final Throwable throwable) {
+    public static <T> Completable<T> suppliedAsync(final Supplier<T> supplier, final Executor executor) {
+        return suppliedAsync(supplier, executor, DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public static <T> Completable<T> suppliedAsync(final Supplier<T> supplier, final Executor executor, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+        final Completable<T> ret = new Completable<>();
+
+        class AsyncSuppliedCompletable implements Runnable, CompletableFuture.AsynchronousCompletionTask {
+            @Override
+            public void run() {
+                try {
+                    ret.complete(supplier.get());
+                } catch (final Throwable throwable) {
+                    Throwable complete;
+                    try {
+                        complete = exceptionHandler.apply(throwable);
+                    } catch (final Throwable thr2) {
+                        throwable.addSuppressed(thr2);
+                        complete = throwable;
+                    }
+                    ret.completeExceptionally(complete);
+                }
+            }
+        }
+
         try {
-            consumer.accept(result, throwable);
-        } catch (final ThreadDeath death) {
-            throw death;
-        } catch (final Throwable throwable2) {
-            LOGGER.error("Failed to complete callback " + ConcurrentUtil.genericToString(consumer), throwable2);
+            executor.execute(new AsyncSuppliedCompletable());
+        } catch (final Throwable throwable) {
+            Throwable complete;
+            try {
+                complete = exceptionHandler.apply(throwable);
+            } catch (final Throwable thr2) {
+                throwable.addSuppressed(thr2);
+                complete = throwable;
+            }
+            ret.completeExceptionally(complete);
+        }
+
+        return ret;
+    }
+
+    private boolean completeRaw(final Object value) {
+        if ((Object)RESULT_HANDLE.getVolatile(this) != null || !(boolean)RESULT_HANDLE.compareAndSet(this, (Object)null, value)) {
+            return false;
+        }
+
+        this.propagateStack();
+        return true;
+    }
+
+    public boolean complete(final T result) {
+        return this.completeRaw(maskNull(result));
+    }
+
+    public boolean completeExceptionally(final Throwable exception) {
+        Validate.notNull(exception, "Exception may not be null");
+
+        return this.completeRaw(new ExceptionResult(exception));
+    }
+
+    public boolean isDone() {
+        return this.getResultVolatile() != null;
+    }
+
+    public boolean isNormallyComplete() {
+        return this.getResultVolatile() != null && !(this.getResultVolatile() instanceof ExceptionResult);
+    }
+
+    public boolean isExceptionallyComplete() {
+        return this.getResultVolatile() instanceof ExceptionResult;
+    }
+
+    public Throwable getException() {
+        final Object res = this.getResultVolatile();
+        if (res == null) {
+            return null;
+        }
+
+        if (!(res instanceof ExceptionResult exRes)) {
+            throw new IllegalStateException("Not completed exceptionally");
+        }
+
+        return exRes.ex;
+    }
+
+    public T getNow(final T dfl) throws CompletionException {
+        final Object res = this.getResultVolatile();
+        if (res == null) {
+            return dfl;
+        }
+
+        if (res instanceof ExceptionResult exRes) {
+            throw new CompletionException(exRes.ex);
+        }
+
+        return (T)unmaskNull(res);
+    }
+
+    public T join() throws CompletionException {
+        if (this.isDone()) {
+            return this.getNow(null);
+        }
+
+        final UnparkTransform<T> unparkTransform = new UnparkTransform<>(this, Thread.currentThread());
+
+        this.pushStackOrRun(unparkTransform);
+
+        boolean interuptted = false;
+        while (!unparkTransform.isReleasable()) {
+            try {
+                ForkJoinPool.managedBlock(unparkTransform);
+            } catch (final InterruptedException ex) {
+                interuptted = true;
+            }
+        }
+
+        if (interuptted) {
+            Thread.currentThread().interrupt();
+        }
+
+        return this.getNow(null);
+    }
+
+    public CompletableFuture<T> toFuture() {
+        final Object rawResult = this.getResultVolatile();
+        if (rawResult != null) {
+            if (rawResult instanceof ExceptionResult exRes) {
+                return CompletableFuture.failedFuture(exRes.ex);
+            } else {
+                return CompletableFuture.completedFuture((T)unmaskNull(rawResult));
+            }
+        }
+
+        final CompletableFuture<T> ret = new CompletableFuture<>();
+
+        class ToFuture implements BiConsumer<T, Throwable> {
+
+            @Override
+            public void accept(final T res, final Throwable ex) {
+                if (ex != null) {
+                    ret.completeExceptionally(ex);
+                } else {
+                    ret.complete(res);
+                }
+            }
+        }
+
+        this.whenComplete(new ToFuture());
+
+        return ret;
+    }
+
+    public static <T> Completable<T> fromFuture(final CompletionStage<T> stage) {
+        final Completable<T> ret = new Completable<>();
+
+        class FromFuture implements BiConsumer<T, Throwable> {
+            @Override
+            public void accept(final T res, final Throwable ex) {
+                if (ex != null) {
+                    ret.completeExceptionally(ex);
+                } else {
+                    ret.complete(res);
+                }
+            }
+        }
+
+        stage.whenComplete(new FromFuture());
+
+        return ret;
+    }
+
+
+    public <U> Completable<U> thenApply(final Function<? super T, ? extends U> function) {
+        return this.thenApply(function, DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public <U> Completable<U> thenApply(final Function<? super T, ? extends U> function, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+        Validate.notNull(function, "Function may not be null");
+        Validate.notNull(exceptionHandler, "Exception handler may not be null");
+
+        final Completable<U> ret = new Completable<>();
+        this.pushStackOrRun(new ApplyTransform<>(null, this, ret, exceptionHandler, function));
+        return ret;
+    }
+
+    public <U> Completable<U> thenApplyAsync(final Function<? super T, ? extends U> function) {
+        return this.thenApplyAsync(function, getDefaultExecutor(), DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public <U> Completable<U> thenApplyAsync(final Function<? super T, ? extends U> function, final Executor executor) {
+        return this.thenApplyAsync(function, executor, DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public <U> Completable<U> thenApplyAsync(final Function<? super T, ? extends U> function, final Executor executor, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+        Validate.notNull(function, "Function may not be null");
+        Validate.notNull(exceptionHandler, "Exception handler may not be null");
+
+        final Completable<U> ret = new Completable<>();
+        this.pushStackOrRun(new ApplyTransform<>(checkExecutor(executor), this, ret, exceptionHandler, function));
+        return ret;
+    }
+
+
+    public Completable<Void> thenAccept(final Consumer<? super T> consumer) {
+        return this.thenAccept(consumer, DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public Completable<Void> thenAccept(final Consumer<? super T> consumer, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+        Validate.notNull(consumer, "Consumer may not be null");
+        Validate.notNull(exceptionHandler, "Exception handler may not be null");
+
+        final Completable<Void> ret = new Completable<>();
+        this.pushStackOrRun(new AcceptTransform<>(null, this, ret, exceptionHandler, consumer));
+        return ret;
+    }
+
+    public Completable<Void> thenAcceptAsync(final Consumer<? super T> consumer) {
+        return this.thenAcceptAsync(consumer, getDefaultExecutor(), DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public Completable<Void> thenAcceptAsync(final Consumer<? super T> consumer, final Executor executor) {
+        return this.thenAcceptAsync(consumer, executor, DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public Completable<Void> thenAcceptAsync(final Consumer<? super T> consumer, final Executor executor, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+        Validate.notNull(consumer, "Consumer may not be null");
+        Validate.notNull(exceptionHandler, "Exception handler may not be null");
+
+        final Completable<Void> ret = new Completable<>();
+        this.pushStackOrRun(new AcceptTransform<>(checkExecutor(executor), this, ret, exceptionHandler, consumer));
+        return ret;
+    }
+
+
+    public Completable<Void> thenRun(final Runnable run) {
+        return this.thenRun(run, DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public Completable<Void> thenRun(final Runnable run, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+        Validate.notNull(run, "Run may not be null");
+        Validate.notNull(exceptionHandler, "Exception handler may not be null");
+
+        final Completable<Void> ret = new Completable<>();
+        this.pushStackOrRun(new RunTransform<>(null, this, ret, exceptionHandler, run));
+        return ret;
+    }
+
+    public Completable<Void> thenRunAsync(final Runnable run) {
+        return this.thenRunAsync(run, getDefaultExecutor(), DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public Completable<Void> thenRunAsync(final Runnable run, final Executor executor) {
+        return this.thenRunAsync(run, executor, DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public Completable<Void> thenRunAsync(final Runnable run, final Executor executor, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+        Validate.notNull(run, "Run may not be null");
+        Validate.notNull(exceptionHandler, "Exception handler may not be null");
+
+        final Completable<Void> ret = new Completable<>();
+        this.pushStackOrRun(new RunTransform<>(checkExecutor(executor), this, ret, exceptionHandler, run));
+        return ret;
+    }
+
+
+    public <U> Completable<U> handle(final BiFunction<? super T, ? super Throwable, ? extends U> function) {
+        return this.handle(function, DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public <U> Completable<U> handle(final BiFunction<? super T, ? super Throwable, ? extends U> function,
+                                     final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+        Validate.notNull(function, "Function may not be null");
+        Validate.notNull(exceptionHandler, "Exception handler may not be null");
+
+        final Completable<U> ret = new Completable<>();
+        this.pushStackOrRun(new HandleTransform<>(null, this, ret, exceptionHandler, function));
+        return ret;
+    }
+
+    public <U> Completable<U> handleAsync(final BiFunction<? super T, ? super Throwable, ? extends U> function) {
+        return this.handleAsync(function, getDefaultExecutor(), DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public <U> Completable<U> handleAsync(final BiFunction<? super T, ? super Throwable, ? extends U> function,
+                                          final Executor executor) {
+        return this.handleAsync(function, executor, DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public <U> Completable<U> handleAsync(final BiFunction<? super T, ? super Throwable, ? extends U> function,
+                                          final Executor executor,
+                                          final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+        Validate.notNull(function, "Function may not be null");
+        Validate.notNull(exceptionHandler, "Exception handler may not be null");
+
+        final Completable<U> ret = new Completable<>();
+        this.pushStackOrRun(new HandleTransform<>(checkExecutor(executor), this, ret, exceptionHandler, function));
+        return ret;
+    }
+
+
+    public Completable<T> whenComplete(final BiConsumer<? super T, ? super Throwable> consumer) {
+        return this.whenComplete(consumer, DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public Completable<T> whenComplete(final BiConsumer<? super T, ? super Throwable> consumer, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+        Validate.notNull(consumer, "Consumer may not be null");
+        Validate.notNull(exceptionHandler, "Exception handler may not be null");
+
+        final Completable<T> ret = new Completable<>();
+        this.pushStackOrRun(new WhenTransform<>(null, this, ret, exceptionHandler, consumer));
+        return ret;
+    }
+
+    public Completable<T> whenCompleteAsync(final BiConsumer<? super T, ? super Throwable> consumer) {
+        return this.whenCompleteAsync(consumer, getDefaultExecutor(), DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public Completable<T> whenCompleteAsync(final BiConsumer<? super T, ? super Throwable> consumer, final Executor executor) {
+        return this.whenCompleteAsync(consumer, executor, DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public Completable<T> whenCompleteAsync(final BiConsumer<? super T, ? super Throwable> consumer, final Executor executor,
+                                            final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+        Validate.notNull(consumer, "Consumer may not be null");
+        Validate.notNull(exceptionHandler, "Exception handler may not be null");
+
+        final Completable<T> ret = new Completable<>();
+        this.pushStackOrRun(new WhenTransform<>(checkExecutor(executor), this, ret, exceptionHandler, consumer));
+        return ret;
+    }
+
+
+    public Completable<T> exceptionally(final Function<Throwable, ? extends T> function) {
+        return this.exceptionally(function, DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public Completable<T> exceptionally(final Function<Throwable, ? extends T> function, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+        Validate.notNull(function, "Function may not be null");
+        Validate.notNull(exceptionHandler, "Exception handler may not be null");
+
+        final Completable<T> ret = new Completable<>();
+        this.pushStackOrRun(new ExceptionallyTransform<>(null, this, ret, exceptionHandler, function));
+        return ret;
+    }
+
+    public Completable<T> exceptionallyAsync(final Function<Throwable, ? extends T> function) {
+        return this.exceptionallyAsync(function, getDefaultExecutor(), DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public Completable<T> exceptionallyAsync(final Function<Throwable, ? extends T> function, final Executor executor) {
+        return this.exceptionallyAsync(function, executor, DEFAULT_EXCEPTION_HANDLER);
+    }
+
+    public Completable<T> exceptionallyAsync(final Function<Throwable, ? extends T> function, final Executor executor,
+                                             final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+        Validate.notNull(function, "Function may not be null");
+        Validate.notNull(exceptionHandler, "Exception handler may not be null");
+
+        final Completable<T> ret = new Completable<>();
+        this.pushStackOrRun(new ExceptionallyTransform<>(checkExecutor(executor), this, ret, exceptionHandler, function));
+        return ret;
+    }
+
+    private static final class ExceptionResult {
+        public final Throwable ex;
+
+        public ExceptionResult(final Throwable ex) {
+            this.ex = ex;
         }
     }
 
-    /**
-     * Adds a waiter that will be completed asynchronously by the complete() calls. If complete()
-     * has already been called, then invokes the consumer synchronously with the completed result.
-     * @param consumer Consumer to be executed on completion
-     * @throws NullPointerException If consumer is null
-     * @return A cancellable which will control the execution of the specified consumer
-     */
-    public Cancellable addWaiter(final BiConsumer<T, Throwable> consumer) {
-        if (this.waiters.add(consumer)) {
-            return new CancellableImpl(consumer);
+    private static abstract class Transform<U, T> implements Runnable, CompletableFuture.AsynchronousCompletionTask {
+
+        private Transform<?, T> next;
+
+        private final Executor executor;
+        protected final Completable<T> from;
+        protected final Completable<U> to;
+        protected final Function<? super Throwable, ? extends Throwable> exceptionHandler;
+
+        protected Transform(final Executor executor, final Completable<T> from, final Completable<U> to,
+                            final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
+            this.executor = executor;
+            this.from = from;
+            this.to = to;
+            this.exceptionHandler = exceptionHandler;
+        }
+
+        // force interface call to become virtual call
+        @Override
+        public abstract void run();
+
+        protected void failed(final Throwable throwable) {
+            Throwable complete;
+            try {
+                complete = this.exceptionHandler.apply(throwable);
+            } catch (final Throwable thr2) {
+                throwable.addSuppressed(thr2);
+                complete = throwable;
+            }
+            this.to.completeExceptionally(complete);
+        }
+
+        public void execute() {
+            if (this.executor == null) {
+                this.run();
+                return;
+            }
+
+            try {
+                this.executor.execute(this);
+            } catch (final Throwable throwable) {
+                this.failed(throwable);
+            }
+        }
+    }
+
+    private static final class ApplyTransform<U, T> extends Transform<U, T> {
+
+        private final Function<? super T, ? extends U> function;
+
+        public ApplyTransform(final Executor executor, final Completable<T> from, final Completable<U> to,
+                              final Function<? super Throwable, ? extends Throwable> exceptionHandler,
+                              final Function<? super T, ? extends U> function) {
+            super(executor, from, to, exceptionHandler);
+            this.function = function;
+        }
+
+        @Override
+        public void run() {
+            final Object result = this.from.getResultPlain();
+            try {
+                if (result instanceof ExceptionResult exRes) {
+                    this.to.completeExceptionally(exRes.ex);
+                } else {
+                    this.to.complete(this.function.apply((T)unmaskNull(result)));
+                }
+            } catch (final Throwable throwable) {
+                this.failed(throwable);
+            }
         }
-        this.completeWaiter(consumer, this.result, this.throwable);
-        return new CancellableImpl(consumer);
     }
 
-    public void complete(final T result) {
-        this.result = result;
-        this.completeAllWaiters(result, null);
+    private static final class AcceptTransform<T> extends Transform<Void, T> {
+        private final Consumer<? super T> consumer;
+
+        public AcceptTransform(final Executor executor, final Completable<T> from, final Completable<Void> to,
+                               final Function<? super Throwable, ? extends Throwable> exceptionHandler,
+                               final Consumer<? super T> consumer) {
+            super(executor, from, to, exceptionHandler);
+            this.consumer = consumer;
+        }
+
+        @Override
+        public void run() {
+            final Object result = this.from.getResultPlain();
+            try {
+                if (result instanceof ExceptionResult exRes) {
+                    this.to.completeExceptionally(exRes.ex);
+                } else {
+                    this.consumer.accept((T)unmaskNull(result));
+                    this.to.complete(null);
+                }
+            } catch (final Throwable throwable) {
+                this.failed(throwable);
+            }
+        }
     }
 
-    public void completeWithThrowable(final Throwable throwable) {
-        if (throwable == null) {
-            throw new NullPointerException("Throwable cannot be null");
+    private static final class RunTransform<T> extends Transform<Void, T> {
+        private final Runnable run;
+
+        public RunTransform(final Executor executor, final Completable<T> from, final Completable<Void> to,
+                            final Function<? super Throwable, ? extends Throwable> exceptionHandler,
+                            final Runnable run) {
+            super(executor, from, to, exceptionHandler);
+            this.run = run;
+        }
+
+        @Override
+        public void run() {
+            final Object result = this.from.getResultPlain();
+            try {
+                if (result instanceof ExceptionResult exRes) {
+                    this.to.completeExceptionally(exRes.ex);
+                } else {
+                    this.run.run();
+                    this.to.complete(null);
+                }
+            } catch (final Throwable throwable) {
+                this.failed(throwable);
+            }
         }
-        this.throwable = throwable;
-        this.completeAllWaiters(null, throwable);
     }
 
-    private final class CancellableImpl implements Cancellable {
+    private static final class HandleTransform<U, T> extends Transform<U, T> {
+
+        private final BiFunction<? super T, ? super Throwable, ? extends U> function;
+
+        public HandleTransform(final Executor executor, final Completable<T> from, final Completable<U> to,
+                               final Function<? super Throwable, ? extends Throwable> exceptionHandler,
+                               final BiFunction<? super T, ? super Throwable, ? extends U> function) {
+            super(executor, from, to, exceptionHandler);
+            this.function = function;
+        }
 
-        private final BiConsumer<T, Throwable> waiter;
+        @Override
+        public void run() {
+            final Object result = this.from.getResultPlain();
+            try {
+                if (result instanceof ExceptionResult exRes) {
+                    this.to.complete(this.function.apply(null, exRes.ex));
+                } else {
+                    this.to.complete(this.function.apply((T)unmaskNull(result), null));
+                }
+            } catch (final Throwable throwable) {
+                this.failed(throwable);
+            }
+        }
+    }
+
+    private static final class WhenTransform<T> extends Transform<T, T> {
+
+        private final BiConsumer<? super T, ? super Throwable> consumer;
+
+        public WhenTransform(final Executor executor, final Completable<T> from, final Completable<T> to,
+                              final Function<? super Throwable, ? extends Throwable> exceptionHandler,
+                              final BiConsumer<? super T, ? super Throwable> consumer) {
+            super(executor, from, to, exceptionHandler);
+            this.consumer = consumer;
+        }
+
+        @Override
+        public void run() {
+            final Object result = this.from.getResultPlain();
+            try {
+                if (result instanceof ExceptionResult exRes) {
+                    this.consumer.accept(null, exRes.ex);
+                    this.to.completeExceptionally(exRes.ex);
+                } else {
+                    final T unmasked = (T)unmaskNull(result);
+                    this.consumer.accept(unmasked, null);
+                    this.to.complete(unmasked);
+                }
+            } catch (final Throwable throwable) {
+                this.failed(throwable);
+            }
+        }
+    }
+
+    private static final class ExceptionallyTransform<T> extends Transform<T, T> {
+        private final Function<Throwable, ? extends T> function;
+
+        public ExceptionallyTransform(final Executor executor, final Completable<T> from, final Completable<T> to,
+                              final Function<? super Throwable, ? extends Throwable> exceptionHandler,
+                              final Function<Throwable, ? extends T> function) {
+            super(executor, from, to, exceptionHandler);
+            this.function = function;
+        }
+
+        @Override
+        public void run() {
+            final Object result = this.from.getResultPlain();
+            try {
+                if (result instanceof ExceptionResult exRes) {
+                    this.to.complete(this.function.apply(exRes.ex));
+                } else {
+                    this.to.complete((T)unmaskNull(result));
+                }
+            } catch (final Throwable throwable) {
+                this.failed(throwable);
+            }
+        }
+    }
+
+    private static final class UnparkTransform<T> extends Transform<Void, T> implements ForkJoinPool.ManagedBlocker {
+
+        private volatile Thread thread;
+
+        public UnparkTransform(final Completable<T> from, final Thread target) {
+            super(null, from, null, null);
+            this.thread = target;
+        }
+
+        @Override
+        public void run() {
+            final Thread t = this.thread;
+            this.thread = null;
+            LockSupport.unpark(t);
+        }
+
+        @Override
+        public boolean block() throws InterruptedException {
+            while (!this.isReleasable()) {
+                if (Thread.interrupted()) {
+                    throw new InterruptedException();
+                }
+                LockSupport.park(this);
+            }
 
-        private CancellableImpl(final BiConsumer<T, Throwable> waiter) {
-            this.waiter = waiter;
+            return true;
         }
 
         @Override
-        public boolean cancel() {
-            return Completable.this.waiters.remove(this.waiter);
+        public boolean isReleasable() {
+            return this.thread == null;
         }
     }
 }
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/BaseExecutor.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/BaseExecutor.java
deleted file mode 100644
index 18d646676fd022afd64afaac30ec1bd283a73b0e..0000000000000000000000000000000000000000
--- a/src/main/java/ca/spottedleaf/concurrentutil/executor/BaseExecutor.java
+++ /dev/null
@@ -1,208 +0,0 @@
-package ca.spottedleaf.concurrentutil.executor;
-
-import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
-import java.util.function.BooleanSupplier;
-
-/**
- * Base implementation for an abstract queue of tasks which are executed either synchronously or asynchronously.
- *
- * <p>
- * The implementation supports tracking task executions using {@link #getTotalTasksScheduled()} and
- * {@link #getTotalTasksExecuted()}, and optionally shutting down the executor using {@link #shutdown()}
- * </p>
- *
- * <p>
- * The base implementation does not provide a method to queue a task for execution, rather that is specified in
- * the specific implementation. However, it is required that a specific implementation provides a method to
- * <i>queue</i> a task or <i>create</i> a task. A <i>queued</i> task is one which will eventually be executed,
- * and a <i>created</i> task must be queued to execute via {@link BaseTask#queue()} or be executed manually via
- * {@link BaseTask#execute()}. This choice of delaying the queueing of a task may be useful to provide a task handle
- * which may be cancelled or adjusted before the actual real task logic is ready to be executed.
- * </p>
- */
-public interface BaseExecutor {
-
-    /**
-     * Returns whether every task scheduled to this queue has been removed and executed or cancelled. If no tasks have been queued,
-     * returns {@code true}.
-     *
-     * @return {@code true} if all tasks that have been queued have finished executing or no tasks have been queued, {@code false} otherwise.
-     */
-    public default boolean haveAllTasksExecuted() {
-        // order is important
-        // if new tasks are scheduled between the reading of these variables, scheduled is guaranteed to be higher -
-        // so our check fails, and we try again
-        final long completed = this.getTotalTasksExecuted();
-        final long scheduled = this.getTotalTasksScheduled();
-
-        return completed == scheduled;
-    }
-
-    /**
-     * Returns the number of tasks that have been scheduled or execute or are pending to be scheduled.
-     */
-    public long getTotalTasksScheduled();
-
-    /**
-     * Returns the number of tasks that have fully been executed.
-     */
-    public long getTotalTasksExecuted();
-
-    /**
-     * Waits until this queue has had all of its tasks executed (NOT removed). See {@link #haveAllTasksExecuted()}
-     * <p>
-     *     This call is most effective after a {@link #shutdown()} call, as the shutdown call guarantees no tasks can
-     *     be executed and the waitUntilAllExecuted call makes sure the queue is empty. Effectively, using shutdown then using
-     *     waitUntilAllExecuted ensures this queue is empty - and most importantly, will remain empty.
-     * </p>
-     * <p>
-     *     This method is not guaranteed to be immediately responsive to queue state, so calls may take significantly more
-     *     time than expected. Effectively, do not rely on this call being fast - even if there are few tasks scheduled.
-     * </p>
-     * <p>
-     *     Note: Interruptions to the the current thread have no effect. Interrupt status is also not affected by this call.
-     * </p>
-     *
-     * @throws IllegalStateException If the current thread is not allowed to wait
-     */
-    public default void waitUntilAllExecuted() throws IllegalStateException {
-        long failures = 1L; // start at 0.25ms
-
-        while (!this.haveAllTasksExecuted()) {
-            Thread.yield();
-            failures = ConcurrentUtil.linearLongBackoff(failures, 250_000L, 5_000_000L); // 500us, 5ms
-        }
-    }
-
-    /**
-     * Executes the next available task.
-     *
-     * @return {@code true} if a task was executed, {@code false} otherwise
-     * @throws IllegalStateException If the current thread is not allowed to execute a task
-     */
-    public boolean executeTask() throws IllegalStateException;
-
-    /**
-     * Executes all queued tasks.
-     *
-     * @return {@code true} if a task was executed, {@code false} otherwise
-     * @throws IllegalStateException If the current thread is not allowed to execute a task
-     */
-    public default boolean executeAll() {
-        if (!this.executeTask()) {
-            return false;
-        }
-
-        while (this.executeTask());
-
-        return true;
-    }
-
-    /**
-     * Waits and executes tasks until the condition returns {@code true}.
-     * <p>
-     *     WARNING: This function is <i>not</i> suitable for waiting until a deadline!
-     *     Use {@link #executeUntil(long)} or {@link #executeConditionally(BooleanSupplier, long)} instead.
-     * </p>
-     */
-    public default void executeConditionally(final BooleanSupplier condition) {
-        long failures = 0;
-        while (!condition.getAsBoolean()) {
-            if (this.executeTask()) {
-                failures = failures >>> 2;
-            } else {
-                failures = ConcurrentUtil.linearLongBackoff(failures, 100_000L, 10_000_000L); // 100us, 10ms
-            }
-        }
-    }
-
-    /**
-     * Waits and executes tasks until the condition returns {@code true} or {@code System.nanoTime() - deadline >= 0}.
-     */
-    public default void executeConditionally(final BooleanSupplier condition, final long deadline) {
-        long failures = 0;
-        // double check deadline; we don't know how expensive the condition is
-        while ((System.nanoTime() - deadline < 0L) && !condition.getAsBoolean() && (System.nanoTime() - deadline < 0L)) {
-            if (this.executeTask()) {
-                failures = failures >>> 2;
-            } else {
-                failures = ConcurrentUtil.linearLongBackoffDeadline(failures, 100_000L, 10_000_000L, deadline); // 100us, 10ms
-            }
-        }
-    }
-
-    /**
-     * Waits and executes tasks until {@code System.nanoTime() - deadline >= 0}.
-     */
-    public default void executeUntil(final long deadline) {
-        long failures = 0;
-        while (System.nanoTime() - deadline < 0L) {
-            if (this.executeTask()) {
-                failures = failures >>> 2;
-            } else {
-                failures = ConcurrentUtil.linearLongBackoffDeadline(failures, 100_000L, 10_000_000L, deadline); // 100us, 10ms
-            }
-        }
-    }
-
-    /**
-     * Prevent further additions to this queue. Attempts to add after this call has completed (potentially during) will
-     * result in {@link IllegalStateException} being thrown.
-     * <p>
-     *     This operation is atomic with respect to other shutdown calls
-     * </p>
-     * <p>
-     *     After this call has completed, regardless of return value, this queue will be shutdown.
-     * </p>
-     *
-     * @return {@code true} if the queue was shutdown, {@code false} if it has shut down already
-     * @throws UnsupportedOperationException If this queue does not support shutdown
-     * @see #isShutdown()
-     */
-    public default boolean shutdown() throws UnsupportedOperationException {
-        throw new UnsupportedOperationException();
-    }
-
-    /**
-     * Returns whether this queue has shut down. Effectively, whether new tasks will be rejected - this method
-     * does not indicate whether all the tasks scheduled have been executed.
-     * @return Returns whether this queue has shut down.
-     * @see #waitUntilAllExecuted()
-     */
-    public default boolean isShutdown() {
-        return false;
-    }
-
-    /**
-     * Task object returned for any {@link BaseExecutor} scheduled task.
-     * @see BaseExecutor
-     */
-    public static interface BaseTask extends Cancellable {
-
-        /**
-         * Causes a lazily queued task to become queued or executed
-         *
-         * @throws IllegalStateException If the backing queue has shutdown
-         * @return {@code true} If the task was queued, {@code false} if the task was already queued/cancelled/executed
-         */
-        public boolean queue();
-
-        /**
-         * Forces this task to be marked as completed.
-         *
-         * @return {@code true} if the task was cancelled, {@code false} if the task has already completed or is being completed.
-         */
-        @Override
-        public boolean cancel();
-
-        /**
-         * Executes this task. This will also mark the task as completing.
-         * <p>
-         *     Exceptions thrown from the runnable will be rethrown.
-         * </p>
-         *
-         * @return {@code true} if this task was executed, {@code false} if it was already marked as completed.
-         */
-        public boolean execute();
-    }
-}
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/PrioritisedExecutor.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/PrioritisedExecutor.java
new file mode 100644
index 0000000000000000000000000000000000000000..17cbaee1e89bd3f6d905e640d20d0119ab0570a0
--- /dev/null
+++ b/src/main/java/ca/spottedleaf/concurrentutil/executor/PrioritisedExecutor.java
@@ -0,0 +1,271 @@
+package ca.spottedleaf.concurrentutil.executor;
+
+import ca.spottedleaf.concurrentutil.util.Priority;
+
+public interface PrioritisedExecutor {
+
+    /**
+     * Returns the number of tasks that have been scheduled are pending to be scheduled.
+     */
+    public long getTotalTasksScheduled();
+
+    /**
+     * Returns the number of tasks that have been executed.
+     */
+    public long getTotalTasksExecuted();
+
+    /**
+     * Generates the next suborder id.
+     * @return The next suborder id.
+     */
+    public long generateNextSubOrder();
+
+    /**
+     * Executes the next available task.
+     * <p>
+     *     If there is a task with priority {@link Priority#BLOCKING} available, then that such task is executed.
+     * </p>
+     * <p>
+     *     If there is a task with priority {@link Priority#IDLE} available then that task is only executed
+     *     when there are no other tasks available with a higher priority.
+     * </p>
+     * <p>
+     *     If there are no tasks that have priority {@link Priority#BLOCKING} or {@link Priority#IDLE}, then
+     *     this function will be biased to execute tasks that have higher priorities.
+     * </p>
+     *
+     * @return {@code true} if a task was executed, {@code false} otherwise
+     * @throws IllegalStateException If the current thread is not allowed to execute a task
+     */
+    public boolean executeTask() throws IllegalStateException;
+
+    /**
+     * Prevent further additions to this executor. Attempts to add after this call has completed (potentially during) will
+     * result in {@link IllegalStateException} being thrown.
+     * <p>
+     *     This operation is atomic with respect to other shutdown calls
+     * </p>
+     * <p>
+     *     After this call has completed, regardless of return value, this executor will be shutdown.
+     * </p>
+     *
+     * @return {@code true} if the executor was shutdown, {@code false} if it has shut down already
+     * @see #isShutdown()
+     */
+    public boolean shutdown();
+
+    /**
+     * Returns whether this executor has shut down. Effectively, returns whether new tasks will be rejected.
+     * This method does not indicate whether all the tasks scheduled have been executed.
+     * @return Returns whether this executor has shut down.
+     */
+    public boolean isShutdown();
+
+    /**
+     * Queues or executes a task at {@link Priority#NORMAL} priority.
+     * @param task The task to run.
+     *
+     * @throws IllegalStateException If this executor has shutdown.
+     * @throws NullPointerException If the task is null
+     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
+     *         associated with the parameter
+     */
+    public PrioritisedTask queueTask(final Runnable task);
+
+    /**
+     * Queues or executes a task.
+     *
+     * @param task The task to run.
+     * @param priority The priority for the task.
+     *
+     * @throws IllegalStateException If this executor has shutdown.
+     * @throws NullPointerException If the task is null
+     * @throws IllegalArgumentException If the priority is invalid.
+     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
+     *         associated with the parameter
+     */
+    public PrioritisedTask queueTask(final Runnable task, final Priority priority);
+
+    /**
+     * Queues or executes a task.
+     *
+     * @param task The task to run.
+     * @param priority The priority for the task.
+     * @param subOrder The task's suborder.
+     *
+     * @throws IllegalStateException If this executor has shutdown.
+     * @throws NullPointerException If the task is null
+     * @throws IllegalArgumentException If the priority is invalid.
+     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
+     *         associated with the parameter
+     */
+    public PrioritisedTask queueTask(final Runnable task, final Priority priority, final long subOrder);
+
+    /**
+     * Creates, but does not queue or execute, a task at {@link Priority#NORMAL} priority.
+     * @param task The task to run.
+     *
+     * @throws NullPointerException If the task is null
+     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
+     *         associated with the parameter
+     */
+    public PrioritisedTask createTask(final Runnable task);
+
+    /**
+     * Creates, but does not queue or execute, a task at {@link Priority#NORMAL} priority.
+     *
+     * @param task The task to run.
+     * @param priority The priority for the task.
+     *
+     * @throws NullPointerException If the task is null
+     * @throws IllegalArgumentException If the priority is invalid.
+     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
+     *         associated with the parameter
+     */
+    public PrioritisedTask createTask(final Runnable task, final Priority priority);
+
+    /**
+     * Creates, but does not queue or execute, a task at {@link Priority#NORMAL} priority.
+     *
+     * @param task The task to run.
+     * @param priority The priority for the task.
+     * @param subOrder The task's suborder.
+     *
+     * @throws NullPointerException If the task is null
+     * @throws IllegalArgumentException If the priority is invalid.
+     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
+     *         associated with the parameter
+     */
+    public PrioritisedTask createTask(final Runnable task, final Priority priority, final long subOrder);
+
+    public static interface PrioritisedTask extends Cancellable {
+
+        /**
+         * Returns the executor associated with this task.
+         * @return The executor associated with this task.
+         */
+        public PrioritisedExecutor getExecutor();
+
+        /**
+         * Causes a lazily queued task to become queued or executed
+         *
+         * @throws IllegalStateException If the backing executor has shutdown
+         * @return {@code true} If the task was queued, {@code false} if the task was already queued/cancelled/executed
+         */
+        public boolean queue();
+
+        /**
+         * Returns whether this task has been queued and is not completing.
+         * @return {@code true} If the task has been queued, {@code false} if the task has not been queued or is marked
+         *         as completing.
+         */
+        public boolean isQueued();
+
+        /**
+         * Forces this task to be marked as completed.
+         *
+         * @return {@code true} if the task was cancelled, {@code false} if the task has already completed
+         *         or is being completed.
+         */
+        @Override
+        public boolean cancel();
+
+        /**
+         * Executes this task. This will also mark the task as completing.
+         * <p>
+         *     Exceptions thrown from the runnable will be rethrown.
+         * </p>
+         *
+         * @return {@code true} if this task was executed, {@code false} if it was already marked as completed.
+         */
+        public boolean execute();
+
+        /**
+         * Returns the current priority. Note that {@link Priority#COMPLETING} will be returned
+         * if this task is completing or has completed.
+         */
+        public Priority getPriority();
+
+        /**
+         * Attempts to set this task's priority level to the level specified.
+         *
+         * @param priority Specified priority level.
+         *
+         * @throws IllegalArgumentException If the priority is invalid
+         * @return {@code true} if successful, {@code false} if this task is completing or has completed or the queue
+         *         this task was scheduled on was shutdown, or if the priority was already at the specified level.
+         */
+        public boolean setPriority(final Priority priority);
+
+        /**
+         * Attempts to raise the priority to the priority level specified.
+         *
+         * @param priority Priority specified
+         *
+         * @throws IllegalArgumentException If the priority is invalid
+         * @return {@code false} if the current task is completing, {@code true} if the priority was raised to the
+         *          specified level or was already at the specified level or higher.
+         */
+        public boolean raisePriority(final Priority priority);
+
+        /**
+         * Attempts to lower the priority to the priority level specified.
+         *
+         * @param priority Priority specified
+         *
+         * @throws IllegalArgumentException If the priority is invalid
+         * @return {@code false} if the current task is completing, {@code true} if the priority was lowered to the
+         *          specified level or was already at the specified level or lower.
+         */
+        public boolean lowerPriority(final Priority priority);
+
+        /**
+         * Returns the suborder id associated with this task.
+         * @return The suborder id associated with this task.
+         */
+        public long getSubOrder();
+
+        /**
+         * Sets the suborder id associated with this task. Ths function has no effect when this task
+         * is completing or is completed.
+         *
+         * @param subOrder Specified new sub order.
+         *
+         * @return {@code true} if successful, {@code false} if this task is completing or has completed or the queue
+         *         this task was scheduled on was shutdown, or if the current suborder is the same as the new sub order.
+         */
+        public boolean setSubOrder(final long subOrder);
+
+        /**
+         * Attempts to raise the suborder to the suborder specified.
+         *
+         * @param subOrder Specified new sub order.
+         *
+         * @return {@code false} if the current task is completing, {@code true} if the suborder was raised to the
+         *          specified suborder or was already at the specified suborder or higher.
+         */
+        public boolean raiseSubOrder(final long subOrder);
+
+        /**
+         * Attempts to lower the suborder to the suborder specified.
+         *
+         * @param subOrder Specified new sub order.
+         *
+         * @return {@code false} if the current task is completing, {@code true} if the suborder was lowered to the
+         *          specified suborder or was already at the specified suborder or lower.
+         */
+        public boolean lowerSubOrder(final long subOrder);
+
+        /**
+         * Sets the priority and suborder id associated with this task. Ths function has no effect when this task
+         * is completing or is completed.
+         *
+         * @param priority Priority specified
+         * @param subOrder Specified new sub order.
+         * @return {@code true} if successful, {@code false} if this task is completing or has completed or the queue
+         *         this task was scheduled on was shutdown, or if the current priority and suborder are the same as
+         *         the parameters.
+         */
+        public boolean setPriorityAndSubOrder(final Priority priority, final long subOrder);
+    }
+}
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/queue/PrioritisedTaskQueue.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/queue/PrioritisedTaskQueue.java
new file mode 100644
index 0000000000000000000000000000000000000000..edb8c6611bdc9aced2714b963e00bbb7829603d2
--- /dev/null
+++ b/src/main/java/ca/spottedleaf/concurrentutil/executor/queue/PrioritisedTaskQueue.java
@@ -0,0 +1,454 @@
+package ca.spottedleaf.concurrentutil.executor.queue;
+
+import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
+import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
+import ca.spottedleaf.concurrentutil.util.Priority;
+import java.lang.invoke.VarHandle;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.concurrent.ConcurrentSkipListMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+
+public final class PrioritisedTaskQueue implements PrioritisedExecutor {
+
+    /**
+     * Required for tie-breaking in the queue
+     */
+    private final AtomicLong taskIdGenerator = new AtomicLong();
+    private final AtomicLong scheduledTasks = new AtomicLong();
+    private final AtomicLong executedTasks = new AtomicLong();
+    private final AtomicLong subOrderGenerator = new AtomicLong();
+    private final AtomicBoolean shutdown = new AtomicBoolean();
+    private final ConcurrentSkipListMap<PrioritisedQueuedTask.Holder, Boolean> tasks = new ConcurrentSkipListMap<>(PrioritisedQueuedTask.COMPARATOR);
+
+    @Override
+    public long getTotalTasksScheduled() {
+        return this.scheduledTasks.get();
+    }
+
+    @Override
+    public long getTotalTasksExecuted() {
+        return this.executedTasks.get();
+    }
+
+    @Override
+    public long generateNextSubOrder() {
+        return this.subOrderGenerator.getAndIncrement();
+    }
+
+    @Override
+    public boolean shutdown() {
+        return !this.shutdown.getAndSet(true);
+    }
+
+    @Override
+    public boolean isShutdown() {
+        return this.shutdown.get();
+    }
+
+    public PrioritisedTask peekFirst() {
+        final Map.Entry<PrioritisedQueuedTask.Holder, Boolean> firstEntry = this.tasks.firstEntry();
+        return firstEntry == null ? null : firstEntry.getKey().task;
+    }
+
+    public Priority getHighestPriority() {
+        final Map.Entry<PrioritisedQueuedTask.Holder, Boolean> firstEntry = this.tasks.firstEntry();
+        return firstEntry == null ? null : Priority.getPriority(firstEntry.getKey().priority);
+    }
+
+    public boolean hasNoScheduledTasks() {
+        final long executedTasks = this.executedTasks.get();
+        final long scheduledTasks = this.scheduledTasks.get();
+
+        return executedTasks == scheduledTasks;
+    }
+
+    public PrioritySubOrderPair getHighestPrioritySubOrder() {
+        final Map.Entry<PrioritisedQueuedTask.Holder, Boolean> firstEntry = this.tasks.firstEntry();
+        if (firstEntry == null) {
+            return null;
+        }
+
+        final PrioritisedQueuedTask.Holder holder = firstEntry.getKey();
+
+        return new PrioritySubOrderPair(Priority.getPriority(holder.priority), holder.subOrder);
+    }
+
+    public Runnable pollTask() {
+        for (;;) {
+            final Map.Entry<PrioritisedQueuedTask.Holder, Boolean> firstEntry = this.tasks.pollFirstEntry();
+            if (firstEntry != null) {
+                final PrioritisedQueuedTask.Holder task = firstEntry.getKey();
+                task.markRemoved();
+                if (!task.task.cancel()) {
+                    continue;
+                }
+                return task.task.execute;
+            }
+
+            return null;
+        }
+    }
+
+    @Override
+    public boolean executeTask() {
+        for (;;) {
+            final Map.Entry<PrioritisedQueuedTask.Holder, Boolean> firstEntry = this.tasks.pollFirstEntry();
+            if (firstEntry != null) {
+                final PrioritisedQueuedTask.Holder task = firstEntry.getKey();
+                task.markRemoved();
+                if (!task.task.execute()) {
+                    continue;
+                }
+                return true;
+            }
+
+            return false;
+        }
+    }
+
+    @Override
+    public PrioritisedTask createTask(final Runnable task) {
+        return this.createTask(task, Priority.NORMAL, this.generateNextSubOrder());
+    }
+
+    @Override
+    public PrioritisedTask createTask(final Runnable task, final Priority priority) {
+        return this.createTask(task, priority, this.generateNextSubOrder());
+    }
+
+    @Override
+    public PrioritisedTask createTask(final Runnable task, final Priority priority, final long subOrder) {
+        return new PrioritisedQueuedTask(task, priority, subOrder);
+    }
+
+    @Override
+    public PrioritisedTask queueTask(final Runnable task) {
+        return this.queueTask(task, Priority.NORMAL, this.generateNextSubOrder());
+    }
+
+    @Override
+    public PrioritisedTask queueTask(final Runnable task, final Priority priority) {
+        return this.queueTask(task, priority, this.generateNextSubOrder());
+    }
+
+    @Override
+    public PrioritisedTask queueTask(final Runnable task, final Priority priority, final long subOrder) {
+        final PrioritisedQueuedTask ret = new PrioritisedQueuedTask(task, priority, subOrder);
+
+        ret.queue();
+
+        return ret;
+    }
+
+    private final class PrioritisedQueuedTask implements PrioritisedExecutor.PrioritisedTask {
+        public static final Comparator<PrioritisedQueuedTask.Holder> COMPARATOR = (final PrioritisedQueuedTask.Holder t1, final PrioritisedQueuedTask.Holder t2) -> {
+            final int priorityCompare = t1.priority - t2.priority;
+            if (priorityCompare != 0) {
+                return priorityCompare;
+            }
+
+            final int subOrderCompare = Long.compare(t1.subOrder, t2.subOrder);
+            if (subOrderCompare != 0) {
+                return subOrderCompare;
+            }
+
+            return Long.compare(t1.id, t2.id);
+        };
+
+        private static final class Holder {
+            private final PrioritisedQueuedTask task;
+            private final int priority;
+            private final long subOrder;
+            private final long id;
+
+            private volatile boolean removed;
+            private static final VarHandle REMOVED_HANDLE = ConcurrentUtil.getVarHandle(Holder.class, "removed", boolean.class);
+
+            private Holder(final PrioritisedQueuedTask task, final int priority, final long subOrder,
+                           final long id) {
+                this.task = task;
+                this.priority = priority;
+                this.subOrder = subOrder;
+                this.id = id;
+            }
+
+            /**
+             * Returns true if marked as removed
+             */
+            public boolean markRemoved() {
+                return !(boolean)REMOVED_HANDLE.getAndSet((Holder)this, (boolean)true);
+            }
+        }
+
+        private final long id;
+        private final Runnable execute;
+
+        private Priority priority;
+        private long subOrder;
+        private Holder holder;
+
+        public PrioritisedQueuedTask(final Runnable execute, final Priority priority, final long subOrder) {
+            if (!Priority.isValidPriority(priority)) {
+                throw new IllegalArgumentException("Invalid priority " + priority);
+            }
+
+            this.execute = execute;
+            this.priority = priority;
+            this.subOrder = subOrder;
+            this.id = PrioritisedTaskQueue.this.taskIdGenerator.getAndIncrement();
+        }
+
+        @Override
+        public PrioritisedExecutor getExecutor() {
+            return PrioritisedTaskQueue.this;
+        }
+
+        @Override
+        public boolean queue() {
+            synchronized (this) {
+                if (this.holder != null || this.priority == Priority.COMPLETING) {
+                    return false;
+                }
+
+                if (PrioritisedTaskQueue.this.isShutdown()) {
+                    throw new IllegalStateException("Queue is shutdown");
+                }
+
+                final Holder holder = new Holder(this, this.priority.priority, this.subOrder, this.id);
+                this.holder = holder;
+
+                PrioritisedTaskQueue.this.scheduledTasks.getAndIncrement();
+                PrioritisedTaskQueue.this.tasks.put(holder, Boolean.TRUE);
+            }
+
+            if (PrioritisedTaskQueue.this.isShutdown()) {
+                this.cancel();
+                throw new IllegalStateException("Queue is shutdown");
+            }
+
+
+            return true;
+        }
+
+        @Override
+        public boolean isQueued() {
+            synchronized (this) {
+                return this.holder != null && this.priority != Priority.COMPLETING;
+            }
+        }
+
+        @Override
+        public boolean cancel() {
+            synchronized (this) {
+                if (this.priority == Priority.COMPLETING) {
+                    return false;
+                }
+
+                this.priority = Priority.COMPLETING;
+
+                if (this.holder != null) {
+                    if (this.holder.markRemoved()) {
+                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
+                    }
+                    PrioritisedTaskQueue.this.executedTasks.getAndIncrement();
+                }
+
+                return true;
+            }
+        }
+
+        @Override
+        public boolean execute() {
+            final boolean increaseExecuted;
+
+            synchronized (this) {
+                if (this.priority == Priority.COMPLETING) {
+                    return false;
+                }
+
+                this.priority = Priority.COMPLETING;
+
+                if (increaseExecuted = (this.holder != null)) {
+                    if (this.holder.markRemoved()) {
+                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
+                    }
+                }
+            }
+
+            try {
+                this.execute.run();
+                return true;
+            } finally {
+                if (increaseExecuted) {
+                    PrioritisedTaskQueue.this.executedTasks.getAndIncrement();
+                }
+            }
+        }
+
+        @Override
+        public Priority getPriority() {
+            synchronized (this) {
+                return this.priority;
+            }
+        }
+
+        @Override
+        public boolean setPriority(final Priority priority) {
+            synchronized (this) {
+                if (this.priority == Priority.COMPLETING || this.priority == priority) {
+                    return false;
+                }
+
+                this.priority = priority;
+
+                if (this.holder != null) {
+                    if (this.holder.markRemoved()) {
+                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
+                    }
+                    this.holder = new Holder(this, priority.priority, this.subOrder, this.id);
+                    PrioritisedTaskQueue.this.tasks.put(this.holder, Boolean.TRUE);
+                }
+
+                return true;
+            }
+        }
+
+        @Override
+        public boolean raisePriority(final Priority priority) {
+            synchronized (this) {
+                if (this.priority == Priority.COMPLETING || this.priority.isHigherOrEqualPriority(priority)) {
+                    return false;
+                }
+
+                this.priority = priority;
+
+                if (this.holder != null) {
+                    if (this.holder.markRemoved()) {
+                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
+                    }
+                    this.holder = new Holder(this, priority.priority, this.subOrder, this.id);
+                    PrioritisedTaskQueue.this.tasks.put(this.holder, Boolean.TRUE);
+                }
+
+                return true;
+            }
+        }
+
+        @Override
+        public boolean lowerPriority(Priority priority) {
+            synchronized (this) {
+                if (this.priority == Priority.COMPLETING || this.priority.isLowerOrEqualPriority(priority)) {
+                    return false;
+                }
+
+                this.priority = priority;
+
+                if (this.holder != null) {
+                    if (this.holder.markRemoved()) {
+                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
+                    }
+                    this.holder = new Holder(this, priority.priority, this.subOrder, this.id);
+                    PrioritisedTaskQueue.this.tasks.put(this.holder, Boolean.TRUE);
+                }
+
+                return true;
+            }
+        }
+
+        @Override
+        public long getSubOrder() {
+            synchronized (this) {
+                return this.subOrder;
+            }
+        }
+
+        @Override
+        public boolean setSubOrder(final long subOrder) {
+            synchronized (this) {
+                if (this.priority == Priority.COMPLETING || this.subOrder == subOrder) {
+                    return false;
+                }
+
+                this.subOrder = subOrder;
+
+                if (this.holder != null) {
+                    if (this.holder.markRemoved()) {
+                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
+                    }
+                    this.holder = new Holder(this, priority.priority, this.subOrder, this.id);
+                    PrioritisedTaskQueue.this.tasks.put(this.holder, Boolean.TRUE);
+                }
+
+                return true;
+            }
+        }
+
+        @Override
+        public boolean raiseSubOrder(long subOrder) {
+            synchronized (this) {
+                if (this.priority == Priority.COMPLETING || this.subOrder >= subOrder) {
+                    return false;
+                }
+
+                this.subOrder = subOrder;
+
+                if (this.holder != null) {
+                    if (this.holder.markRemoved()) {
+                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
+                    }
+                    this.holder = new Holder(this, priority.priority, this.subOrder, this.id);
+                    PrioritisedTaskQueue.this.tasks.put(this.holder, Boolean.TRUE);
+                }
+
+                return true;
+            }
+        }
+
+        @Override
+        public boolean lowerSubOrder(final long subOrder) {
+            synchronized (this) {
+                if (this.priority == Priority.COMPLETING || this.subOrder <= subOrder) {
+                    return false;
+                }
+
+                this.subOrder = subOrder;
+
+                if (this.holder != null) {
+                    if (this.holder.markRemoved()) {
+                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
+                    }
+                    this.holder = new Holder(this, priority.priority, this.subOrder, this.id);
+                    PrioritisedTaskQueue.this.tasks.put(this.holder, Boolean.TRUE);
+                }
+
+                return true;
+            }
+        }
+
+        @Override
+        public boolean setPriorityAndSubOrder(final Priority priority, final long subOrder) {
+            synchronized (this) {
+                if (this.priority == Priority.COMPLETING || (this.priority == priority && this.subOrder == subOrder)) {
+                    return false;
+                }
+
+                this.priority = priority;
+                this.subOrder = subOrder;
+
+                if (this.holder != null) {
+                    if (this.holder.markRemoved()) {
+                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
+                    }
+                    this.holder = new Holder(this, priority.priority, this.subOrder, this.id);
+                    PrioritisedTaskQueue.this.tasks.put(this.holder, Boolean.TRUE);
+                }
+
+                return true;
+            }
+        }
+    }
+
+    public static record PrioritySubOrderPair(Priority priority, long subOrder) {}
+}
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/DelayedPrioritisedTask.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/DelayedPrioritisedTask.java
deleted file mode 100644
index 3ce10053d4ec51855ad7012abb5d97df1c0e557a..0000000000000000000000000000000000000000
--- a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/DelayedPrioritisedTask.java
+++ /dev/null
@@ -1,170 +0,0 @@
-package ca.spottedleaf.concurrentutil.executor.standard;
-
-import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
-import java.lang.invoke.VarHandle;
-
-public class DelayedPrioritisedTask {
-
-    protected volatile int priority;
-    protected static final VarHandle PRIORITY_HANDLE = ConcurrentUtil.getVarHandle(DelayedPrioritisedTask.class, "priority", int.class);
-
-    protected static final int PRIORITY_SET = Integer.MIN_VALUE >>> 0;
-
-    protected final int getPriorityVolatile() {
-        return (int)PRIORITY_HANDLE.getVolatile((DelayedPrioritisedTask)this);
-    }
-
-    protected final int compareAndExchangePriorityVolatile(final int expect, final int update) {
-        return (int)PRIORITY_HANDLE.compareAndExchange((DelayedPrioritisedTask)this, (int)expect, (int)update);
-    }
-
-    protected final int getAndOrPriorityVolatile(final int val) {
-        return (int)PRIORITY_HANDLE.getAndBitwiseOr((DelayedPrioritisedTask)this, (int)val);
-    }
-
-    protected final void setPriorityPlain(final int val) {
-        PRIORITY_HANDLE.set((DelayedPrioritisedTask)this, (int)val);
-    }
-
-    protected volatile PrioritisedExecutor.PrioritisedTask task;
-    protected static final VarHandle TASK_HANDLE = ConcurrentUtil.getVarHandle(DelayedPrioritisedTask.class, "task", PrioritisedExecutor.PrioritisedTask.class);
-
-    protected PrioritisedExecutor.PrioritisedTask getTaskPlain() {
-        return (PrioritisedExecutor.PrioritisedTask)TASK_HANDLE.get((DelayedPrioritisedTask)this);
-    }
-
-    protected PrioritisedExecutor.PrioritisedTask getTaskVolatile() {
-        return (PrioritisedExecutor.PrioritisedTask)TASK_HANDLE.getVolatile((DelayedPrioritisedTask)this);
-    }
-
-    protected final PrioritisedExecutor.PrioritisedTask compareAndExchangeTaskVolatile(final PrioritisedExecutor.PrioritisedTask expect, final PrioritisedExecutor.PrioritisedTask update) {
-        return (PrioritisedExecutor.PrioritisedTask)TASK_HANDLE.compareAndExchange((DelayedPrioritisedTask)this, (PrioritisedExecutor.PrioritisedTask)expect, (PrioritisedExecutor.PrioritisedTask)update);
-    }
-
-    public DelayedPrioritisedTask(final PrioritisedExecutor.Priority priority) {
-        this.setPriorityPlain(priority.priority);
-    }
-
-    // only public for debugging
-    public int getPriorityInternal() {
-        return this.getPriorityVolatile();
-    }
-
-    public PrioritisedExecutor.PrioritisedTask getTask() {
-        return this.getTaskVolatile();
-    }
-
-    public void setTask(final PrioritisedExecutor.PrioritisedTask task) {
-        int priority = this.getPriorityVolatile();
-
-        if (this.compareAndExchangeTaskVolatile(null, task) != null) {
-            throw new IllegalStateException("setTask() called twice");
-        }
-
-        int failures = 0;
-        for (;;) {
-            task.setPriority(PrioritisedExecutor.Priority.getPriority(priority));
-
-            if (priority == (priority = this.compareAndExchangePriorityVolatile(priority, priority | PRIORITY_SET))) {
-                return;
-            }
-
-            ++failures;
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-        }
-    }
-
-    public PrioritisedExecutor.Priority getPriority() {
-        final int priority = this.getPriorityVolatile();
-        if ((priority & PRIORITY_SET) != 0) {
-            return this.task.getPriority();
-        }
-
-        return PrioritisedExecutor.Priority.getPriority(priority);
-    }
-
-    public void raisePriority(final PrioritisedExecutor.Priority priority) {
-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
-            throw new IllegalArgumentException("Invalid priority " + priority);
-        }
-
-        int failures = 0;
-        for (int curr = this.getPriorityVolatile();;) {
-            if ((curr & PRIORITY_SET) != 0) {
-                this.getTaskPlain().raisePriority(priority);
-                return;
-            }
-
-            if (!priority.isLowerPriority(curr)) {
-                return;
-            }
-
-            if (curr == (curr = this.compareAndExchangePriorityVolatile(curr, priority.priority))) {
-                return;
-            }
-
-            // failed, retry
-
-            ++failures;
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-        }
-    }
-
-    public void setPriority(final PrioritisedExecutor.Priority priority) {
-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
-            throw new IllegalArgumentException("Invalid priority " + priority);
-        }
-
-        int failures = 0;
-        for (int curr = this.getPriorityVolatile();;) {
-            if ((curr & PRIORITY_SET) != 0) {
-                this.getTaskPlain().setPriority(priority);
-                return;
-            }
-
-            if (curr == (curr = this.compareAndExchangePriorityVolatile(curr, priority.priority))) {
-                return;
-            }
-
-            // failed, retry
-
-            ++failures;
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-        }
-    }
-
-    public void lowerPriority(final PrioritisedExecutor.Priority priority) {
-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
-            throw new IllegalArgumentException("Invalid priority " + priority);
-        }
-
-        int failures = 0;
-        for (int curr = this.getPriorityVolatile();;) {
-            if ((curr & PRIORITY_SET) != 0) {
-                this.getTaskPlain().lowerPriority(priority);
-                return;
-            }
-
-            if (!priority.isHigherPriority(curr)) {
-                return;
-            }
-
-            if (curr == (curr = this.compareAndExchangePriorityVolatile(curr, priority.priority))) {
-                return;
-            }
-
-            // failed, retry
-
-            ++failures;
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-        }
-    }
-}
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedExecutor.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedExecutor.java
deleted file mode 100644
index 91beb6f23f257cf265fe3150f760892e605f217a..0000000000000000000000000000000000000000
--- a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedExecutor.java
+++ /dev/null
@@ -1,276 +0,0 @@
-package ca.spottedleaf.concurrentutil.executor.standard;
-
-import ca.spottedleaf.concurrentutil.executor.BaseExecutor;
-
-/**
- * Implementation of {@link BaseExecutor} which schedules tasks to be executed by a given priority.
- * @see BaseExecutor
- */
-public interface PrioritisedExecutor extends BaseExecutor {
-
-    public static enum Priority {
-
-        /**
-         * Priority value indicating the task has completed or is being completed.
-         * This priority cannot be used to schedule tasks.
-         */
-        COMPLETING(-1),
-
-        /**
-         * Absolute highest priority, should only be used for when a task is blocking a time-critical thread.
-         */
-        BLOCKING(),
-
-        /**
-         * Should only be used for urgent but not time-critical tasks.
-         */
-        HIGHEST(),
-
-        /**
-         * Two priorities above normal.
-         */
-        HIGHER(),
-
-        /**
-         * One priority above normal.
-         */
-        HIGH(),
-
-        /**
-         * Default priority.
-         */
-        NORMAL(),
-
-        /**
-         * One priority below normal.
-         */
-        LOW(),
-
-        /**
-         * Two priorities below normal.
-         */
-        LOWER(),
-
-        /**
-         * Use for tasks that should eventually execute, but are not needed to.
-         */
-        LOWEST(),
-
-        /**
-         * Use for tasks that can be delayed indefinitely.
-         */
-        IDLE();
-
-        // returns whether the priority can be scheduled
-        public static boolean isValidPriority(final Priority priority) {
-            return priority != null && priority != Priority.COMPLETING;
-        }
-
-        // returns the higher priority of the two
-        public static Priority max(final Priority p1, final Priority p2) {
-            return p1.isHigherOrEqualPriority(p2) ? p1 : p2;
-        }
-
-        // returns the lower priroity of the two
-        public static Priority min(final Priority p1, final Priority p2) {
-            return p1.isLowerOrEqualPriority(p2) ? p1 : p2;
-        }
-
-        public boolean isHigherOrEqualPriority(final Priority than) {
-            return this.priority <= than.priority;
-        }
-
-        public boolean isHigherPriority(final Priority than) {
-            return this.priority < than.priority;
-        }
-
-        public boolean isLowerOrEqualPriority(final Priority than) {
-            return this.priority >= than.priority;
-        }
-
-        public boolean isLowerPriority(final Priority than) {
-            return this.priority > than.priority;
-        }
-
-        public boolean isHigherOrEqualPriority(final int than) {
-            return this.priority <= than;
-        }
-
-        public boolean isHigherPriority(final int than) {
-            return this.priority < than;
-        }
-
-        public boolean isLowerOrEqualPriority(final int than) {
-            return this.priority >= than;
-        }
-
-        public boolean isLowerPriority(final int than) {
-            return this.priority > than;
-        }
-
-        public static boolean isHigherOrEqualPriority(final int priority, final int than) {
-            return priority <= than;
-        }
-
-        public static boolean isHigherPriority(final int priority, final int than) {
-            return priority < than;
-        }
-
-        public static boolean isLowerOrEqualPriority(final int priority, final int than) {
-            return priority >= than;
-        }
-
-        public static boolean isLowerPriority(final int priority, final int than) {
-            return priority > than;
-        }
-
-        static final Priority[] PRIORITIES = Priority.values();
-
-        /** includes special priorities */
-        public static final int TOTAL_PRIORITIES = PRIORITIES.length;
-
-        public static final int TOTAL_SCHEDULABLE_PRIORITIES = TOTAL_PRIORITIES - 1;
-
-        public static Priority getPriority(final int priority) {
-            return PRIORITIES[priority + 1];
-        }
-
-        private static int priorityCounter;
-
-        private static int nextCounter() {
-            return priorityCounter++;
-        }
-
-        public final int priority;
-
-        Priority() {
-            this(nextCounter());
-        }
-
-        Priority(final int priority) {
-            this.priority = priority;
-        }
-    }
-
-    /**
-     * Executes the next available task.
-     * <p>
-     *     If there is a task with priority {@link PrioritisedExecutor.Priority#BLOCKING} available, then that such task is executed.
-     * </p>
-     * <p>
-     *     If there is a task with priority {@link PrioritisedExecutor.Priority#IDLE} available then that task is only executed
-     *     when there are no other tasks available with a higher priority.
-     * </p>
-     * <p>
-     *     If there are no tasks that have priority {@link PrioritisedExecutor.Priority#BLOCKING} or {@link PrioritisedExecutor.Priority#IDLE}, then
-     *     this function will be biased to execute tasks that have higher priorities.
-     * </p>
-     *
-     * @return {@code true} if a task was executed, {@code false} otherwise
-     * @throws IllegalStateException If the current thread is not allowed to execute a task
-     */
-    @Override
-    public boolean executeTask() throws IllegalStateException;
-
-    /**
-     * Queues or executes a task at {@link Priority#NORMAL} priority.
-     * @param task The task to run.
-     *
-     * @throws IllegalStateException If this queue has shutdown.
-     * @throws NullPointerException If the task is null
-     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
-     * associated with the parameter
-     */
-    public default PrioritisedTask queueRunnable(final Runnable task) {
-        return this.queueRunnable(task, Priority.NORMAL);
-    }
-
-    /**
-     * Queues or executes a task.
-     *
-     * @param task The task to run.
-     * @param priority The priority for the task.
-     *
-     * @throws IllegalStateException If this queue has shutdown.
-     * @throws NullPointerException If the task is null
-     * @throws IllegalArgumentException If the priority is invalid.
-     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
-     * associated with the parameter
-     */
-    public PrioritisedTask queueRunnable(final Runnable task, final Priority priority);
-
-    /**
-     * Creates, but does not execute or queue the task. The task must later be queued via {@link BaseTask#queue()}.
-     *
-     * @param task The task to run.
-     *
-     * @throws IllegalStateException If this queue has shutdown.
-     * @throws NullPointerException If the task is null
-     * @throws IllegalArgumentException If the priority is invalid.
-     * @throws UnsupportedOperationException If this executor does not support lazily queueing tasks
-     * @return The prioritised task associated with the parameters
-     */
-    public default PrioritisedTask createTask(final Runnable task) {
-        return this.createTask(task, Priority.NORMAL);
-    }
-
-    /**
-     * Creates, but does not execute or queue the task. The task must later be queued via {@link BaseTask#queue()}.
-     *
-     * @param task The task to run.
-     * @param priority The priority for the task.
-     *
-     * @throws IllegalStateException If this queue has shutdown.
-     * @throws NullPointerException If the task is null
-     * @throws IllegalArgumentException If the priority is invalid.
-     * @throws UnsupportedOperationException If this executor does not support lazily queueing tasks
-     * @return The prioritised task associated with the parameters
-     */
-    public PrioritisedTask createTask(final Runnable task, final Priority priority);
-
-    /**
-     * Extension of {@link ca.spottedleaf.concurrentutil.executor.BaseExecutor.BaseTask} which adds functions
-     * to retrieve and modify the task's associated priority.
-     *
-     * @see ca.spottedleaf.concurrentutil.executor.BaseExecutor.BaseTask
-     */
-    public static interface PrioritisedTask extends BaseTask {
-
-        /**
-         * Returns the current priority. Note that {@link Priority#COMPLETING} will be returned
-         * if this task is completing or has completed.
-         */
-        public Priority getPriority();
-
-        /**
-         * Attempts to set this task's priority level to the level specified.
-         *
-         * @param priority Specified priority level.
-         *
-         * @throws IllegalArgumentException If the priority is invalid
-         * @return {@code true} if successful, {@code false} if this task is completing or has completed or the queue
-         * this task was scheduled on was shutdown, or if the priority was already at the specified level.
-         */
-        public boolean setPriority(final Priority priority);
-
-        /**
-         * Attempts to raise the priority to the priority level specified.
-         *
-         * @param priority Priority specified
-         *
-         * @throws IllegalArgumentException If the priority is invalid
-         * @return {@code false} if the current task is completing, {@code true} if the priority was raised to the specified level or was already at the specified level or higher.
-         */
-        public boolean raisePriority(final Priority priority);
-
-        /**
-         * Attempts to lower the priority to the priority level specified.
-         *
-         * @param priority Priority specified
-         *
-         * @throws IllegalArgumentException If the priority is invalid
-         * @return {@code false} if the current task is completing, {@code true} if the priority was lowered to the specified level or was already at the specified level or lower.
-         */
-        public boolean lowerPriority(final Priority priority);
-    }
-}
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedThreadPool.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedThreadPool.java
deleted file mode 100644
index 2ba36e29d0d8693f2f5e6c6d195ca27f2a5099aa..0000000000000000000000000000000000000000
--- a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedThreadPool.java
+++ /dev/null
@@ -1,632 +0,0 @@
-package ca.spottedleaf.concurrentutil.executor.standard;
-
-import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.TreeSet;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.BiConsumer;
-
-public final class PrioritisedThreadPool {
-
-    private static final Logger LOGGER = LoggerFactory.getLogger(PrioritisedThreadPool.class);
-
-    private final PrioritisedThread[] threads;
-    private final TreeSet<PrioritisedPoolExecutorImpl> queues = new TreeSet<>(PrioritisedPoolExecutorImpl.comparator());
-    private final String name;
-    private final long queueMaxHoldTime;
-
-    private final ReferenceOpenHashSet<PrioritisedPoolExecutorImpl> nonShutdownQueues = new ReferenceOpenHashSet<>();
-    private final ReferenceOpenHashSet<PrioritisedPoolExecutorImpl> activeQueues = new ReferenceOpenHashSet<>();
-
-    private boolean shutdown;
-
-    private long schedulingIdGenerator;
-
-    private static final long DEFAULT_QUEUE_HOLD_TIME = (long)(5.0e6);
-
-    /**
-     * @param name Specified debug name of this thread pool
-     * @param threads The number of threads to use
-     */
-    public PrioritisedThreadPool(final String name, final int threads) {
-        this(name, threads, null);
-    }
-
-    /**
-     * @param name Specified debug name of this thread pool
-     * @param threads The number of threads to use
-     * @param threadModifier Invoked for each created thread with its incremental id before starting them
-     */
-    public PrioritisedThreadPool(final String name, final int threads, final BiConsumer<Thread, Integer> threadModifier) {
-        this(name, threads, threadModifier, DEFAULT_QUEUE_HOLD_TIME); // 5ms
-    }
-
-    /**
-     * @param name Specified debug name of this thread pool
-     * @param threads The number of threads to use
-     * @param threadModifier Invoked for each created thread with its incremental id before starting them
-     * @param queueHoldTime The maximum amount of time to spend executing tasks in a specific queue before attempting
-     *                      to switch to another queue, per thread
-     */
-    public PrioritisedThreadPool(final String name, final int threads, final BiConsumer<Thread, Integer> threadModifier,
-                                 final long queueHoldTime) { // in ns
-        if (threads <= 0) {
-            throw new IllegalArgumentException("Thread count must be > 0, not " + threads);
-        }
-        if (name == null) {
-            throw new IllegalArgumentException("Name cannot be null");
-        }
-        this.name = name;
-        this.queueMaxHoldTime = queueHoldTime;
-
-        this.threads = new PrioritisedThread[threads];
-        for (int i = 0; i < threads; ++i) {
-            this.threads[i] = new PrioritisedThread(this);
-
-            // set default attributes
-            this.threads[i].setName("Prioritised thread for pool '" + name + "' #" + i);
-            this.threads[i].setUncaughtExceptionHandler((final Thread thread, final Throwable throwable) -> {
-                LOGGER.error("Uncaught exception in thread " + thread.getName(), throwable);
-            });
-
-            // let thread modifier override defaults
-            if (threadModifier != null) {
-                threadModifier.accept(this.threads[i], Integer.valueOf(i));
-            }
-
-            // now the thread can start
-            this.threads[i].start();
-        }
-    }
-
-    /**
-     * Returns an array representing the threads backing this thread pool.
-     */
-    public Thread[] getThreads() {
-        return Arrays.copyOf(this.threads, this.threads.length, Thread[].class);
-    }
-
-    /**
-     * Creates and returns a {@link PrioritisedPoolExecutor} to schedule tasks onto. The returned executor will execute
-     * tasks on this thread pool only.
-     * @param name The debug name of the executor.
-     * @param minParallelism The minimum number of threads to be executing tasks from the returned executor
-     *                       before threads may be allocated to other queues in this thread pool.
-     * @param parallelism The maximum number of threads which may be executing tasks from the returned executor.
-     * @throws IllegalStateException If this thread pool is shut down
-     */
-    public PrioritisedPoolExecutor createExecutor(final String name, final int minParallelism, final int parallelism) {
-        synchronized (this.nonShutdownQueues) {
-            if (this.shutdown) {
-                throw new IllegalStateException("Queue is shutdown: " + this.toString());
-            }
-            final PrioritisedPoolExecutorImpl ret = new PrioritisedPoolExecutorImpl(
-                    this, name,
-                    Math.min(Math.max(1, parallelism), this.threads.length),
-                    Math.min(Math.max(0, minParallelism), this.threads.length)
-            );
-
-            this.nonShutdownQueues.add(ret);
-
-            synchronized (this.activeQueues) {
-                this.activeQueues.add(ret);
-            }
-
-            return ret;
-        }
-    }
-
-    /**
-     * Prevents creation of new queues, shutdowns all non-shutdown queues if specified
-     */
-    public void halt(final boolean shutdownQueues) {
-        synchronized (this.nonShutdownQueues) {
-            this.shutdown = true;
-        }
-        if (shutdownQueues) {
-            final ArrayList<PrioritisedPoolExecutorImpl> queuesToShutdown;
-            synchronized (this.nonShutdownQueues) {
-                this.shutdown = true;
-                queuesToShutdown = new ArrayList<>(this.nonShutdownQueues);
-            }
-
-            for (final PrioritisedPoolExecutorImpl queue : queuesToShutdown) {
-                queue.shutdown();
-            }
-        }
-
-
-        for (final PrioritisedThread thread : this.threads) {
-            // can't kill queue, queue is null
-            thread.halt(false);
-        }
-    }
-
-    /**
-     * Waits until all threads in this pool have shutdown, or until the specified time has passed.
-     * @param msToWait Maximum time to wait.
-     * @return {@code false} if the maximum time passed, {@code true} otherwise.
-     */
-    public boolean join(final long msToWait) {
-        try {
-            return this.join(msToWait, false);
-        } catch (final InterruptedException ex) {
-            throw new IllegalStateException(ex);
-        }
-    }
-
-    /**
-     * Waits until all threads in this pool have shutdown, or until the specified time has passed.
-     * @param msToWait Maximum time to wait.
-     * @return {@code false} if the maximum time passed, {@code true} otherwise.
-     * @throws InterruptedException If this thread is interrupted.
-     */
-    public boolean joinInterruptable(final long msToWait) throws InterruptedException {
-        return this.join(msToWait, true);
-    }
-
-    protected final boolean join(final long msToWait, final boolean interruptable) throws InterruptedException {
-        final long nsToWait = msToWait * (1000 * 1000);
-        final long start = System.nanoTime();
-        final long deadline = start + nsToWait;
-        boolean interrupted = false;
-        try {
-            for (final PrioritisedThread thread : this.threads) {
-                for (;;) {
-                    if (!thread.isAlive()) {
-                        break;
-                    }
-                    final long current = System.nanoTime();
-                    if (current >= deadline) {
-                        return false;
-                    }
-
-                    try {
-                        thread.join(Math.max(1L, (deadline - current) / (1000 * 1000)));
-                    } catch (final InterruptedException ex) {
-                        if (interruptable) {
-                            throw ex;
-                        }
-                        interrupted = true;
-                    }
-                }
-            }
-
-            return true;
-        } finally {
-            if (interrupted) {
-                Thread.currentThread().interrupt();
-            }
-        }
-    }
-
-    /**
-     * Shuts down this thread pool, optionally waiting for all tasks to be executed.
-     * This function will invoke {@link PrioritisedPoolExecutor#shutdown()} on all created executors on this
-     * thread pool.
-     * @param wait Whether to wait for tasks to be executed
-     */
-    public void shutdown(final boolean wait) {
-        final ArrayList<PrioritisedPoolExecutorImpl> queuesToShutdown;
-        synchronized (this.nonShutdownQueues) {
-            this.shutdown = true;
-            queuesToShutdown = new ArrayList<>(this.nonShutdownQueues);
-        }
-
-        for (final PrioritisedPoolExecutorImpl queue : queuesToShutdown) {
-            queue.shutdown();
-        }
-
-        for (final PrioritisedThread thread : this.threads) {
-            // none of these can be true or else NPE
-            thread.close(false, false);
-        }
-
-        if (wait) {
-            final ArrayList<PrioritisedPoolExecutorImpl> queues;
-            synchronized (this.activeQueues) {
-                queues = new ArrayList<>(this.activeQueues);
-            }
-            for (final PrioritisedPoolExecutorImpl queue : queues) {
-                queue.waitUntilAllExecuted();
-            }
-        }
-    }
-
-    protected static final class PrioritisedThread extends PrioritisedQueueExecutorThread {
-
-        protected final PrioritisedThreadPool pool;
-        protected final AtomicBoolean alertedHighPriority = new AtomicBoolean();
-
-        public PrioritisedThread(final PrioritisedThreadPool pool) {
-            super(null);
-            this.pool = pool;
-        }
-
-        public boolean alertHighPriorityExecutor() {
-            if (!this.notifyTasks()) {
-                if (!this.alertedHighPriority.get()) {
-                    this.alertedHighPriority.set(true);
-                }
-                return false;
-            }
-
-            return true;
-        }
-
-        private boolean isAlertedHighPriority() {
-            return this.alertedHighPriority.get() && this.alertedHighPriority.getAndSet(false);
-        }
-
-        @Override
-        protected boolean pollTasks() {
-            final PrioritisedThreadPool pool = this.pool;
-            final TreeSet<PrioritisedPoolExecutorImpl> queues = this.pool.queues;
-
-            boolean ret = false;
-            for (;;) {
-                if (this.halted) {
-                    break;
-                }
-                // try to find a queue
-                // note that if and ONLY IF the queues set is empty, this means there are no tasks for us to execute.
-                // so we can only break when it's empty
-                final PrioritisedPoolExecutorImpl queue;
-                // select queue
-                synchronized (queues) {
-                    queue = queues.pollFirst();
-                    if (queue == null) {
-                        // no tasks to execute
-                        break;
-                    }
-
-                    queue.schedulingId = ++pool.schedulingIdGenerator;
-                    // we own this queue now, so increment the executor count
-                    // do we also need to push this queue up for grabs for another executor?
-                    if (++queue.concurrentExecutors < queue.maximumExecutors) {
-                        // re-add to queues
-                        // it's very important this is done in the same synchronised block for polling, as this prevents
-                        // us from possibly later adding a queue that should not exist in the set
-                        queues.add(queue);
-                        queue.isQueued = true;
-                    } else {
-                        queue.isQueued = false;
-                    }
-                    // note: we cannot drain entries from the queue while holding this lock, as it will cause deadlock
-                    // the queue addition holds the per-queue lock first then acquires the lock we have now, but if we
-                    // try to poll now we don't hold the per queue lock but we do hold the global lock...
-                }
-
-                // parse tasks as long as we are allowed
-                final long start = System.nanoTime();
-                final long deadline = start + pool.queueMaxHoldTime;
-                do {
-                    try {
-                        if (this.halted) {
-                            break;
-                        }
-                        if (!queue.executeTask()) {
-                            // no more tasks, try next queue
-                            break;
-                        }
-                        ret = true;
-                    } catch (final ThreadDeath death) {
-                        throw death; // goodbye world...
-                    } catch (final Throwable throwable) {
-                        LOGGER.error("Exception thrown from thread '" + this.getName() + "' in queue '" + queue.toString() + "'", throwable);
-                    }
-                } while (!this.isAlertedHighPriority() && System.nanoTime() <= deadline);
-
-                synchronized (queues) {
-                    // decrement executors, we are no longer executing
-                    if (queue.isQueued) {
-                        queues.remove(queue);
-                        queue.isQueued = false;
-                    }
-                    if (--queue.concurrentExecutors == 0 && queue.scheduledPriority == null) {
-                        // reset scheduling id once the queue is empty again
-                        // this will ensure empty queues are not prioritised suddenly over active queues once tasks are
-                        // queued
-                        queue.schedulingId = 0L;
-                    }
-
-                    // ensure the executor is queued for execution again
-                    if (!queue.isHalted && queue.scheduledPriority != null) { // make sure it actually has tasks
-                        queues.add(queue);
-                        queue.isQueued = true;
-                    }
-                }
-            }
-
-            return ret;
-        }
-    }
-
-    public interface PrioritisedPoolExecutor extends PrioritisedExecutor {
-
-        /**
-         * Removes this queue from the thread pool without shutting the queue down or waiting for queued tasks to be executed
-         */
-        public void halt();
-
-        /**
-         * Returns whether this executor is scheduled to run tasks or is running tasks, otherwise it returns whether
-         * this queue is not halted and not shutdown.
-         */
-        public boolean isActive();
-    }
-
-    protected static final class PrioritisedPoolExecutorImpl extends PrioritisedThreadedTaskQueue implements PrioritisedPoolExecutor {
-
-        protected final PrioritisedThreadPool pool;
-        protected final long[] priorityCounts = new long[Priority.TOTAL_SCHEDULABLE_PRIORITIES];
-        protected long schedulingId;
-        protected int concurrentExecutors;
-        protected Priority scheduledPriority;
-
-        protected final String name;
-        protected final int maximumExecutors;
-        protected final int minimumExecutors;
-        protected boolean isQueued;
-
-        public PrioritisedPoolExecutorImpl(final PrioritisedThreadPool pool, final String name, final int maximumExecutors, final int minimumExecutors) {
-            this.pool = pool;
-            this.name = name;
-            this.maximumExecutors = maximumExecutors;
-            this.minimumExecutors = minimumExecutors;
-        }
-
-        public static Comparator<PrioritisedPoolExecutorImpl> comparator() {
-            return (final PrioritisedPoolExecutorImpl p1, final PrioritisedPoolExecutorImpl p2) -> {
-                if (p1 == p2) {
-                    return 0;
-                }
-
-                final int belowMin1 = p1.minimumExecutors - p1.concurrentExecutors;
-                final int belowMin2 = p2.minimumExecutors - p2.concurrentExecutors;
-
-                // test minimum executors
-                if (belowMin1 > 0 || belowMin2 > 0) {
-                    // want the largest belowMin to be first
-                    final int minCompare = Integer.compare(belowMin2, belowMin1);
-
-                    if (minCompare != 0) {
-                        return minCompare;
-                    }
-                }
-
-                // prefer higher priority
-                final int priorityCompare = p1.scheduledPriority.ordinal() - p2.scheduledPriority.ordinal();
-                if (priorityCompare != 0) {
-                    return priorityCompare;
-                }
-
-                // try to spread out the executors so that each can have threads executing
-                final int executorCompare = p1.concurrentExecutors - p2.concurrentExecutors;
-                if (executorCompare != 0) {
-                    return executorCompare;
-                }
-
-                // if all else fails here we just choose whichever executor was queued first
-                return Long.compare(p1.schedulingId, p2.schedulingId);
-            };
-        }
-
-        private boolean isHalted;
-
-        @Override
-        public void halt() {
-            final PrioritisedThreadPool pool = this.pool;
-            final TreeSet<PrioritisedPoolExecutorImpl> queues = pool.queues;
-            synchronized (queues) {
-                if (this.isHalted) {
-                    return;
-                }
-                this.isHalted = true;
-                if (this.isQueued) {
-                    queues.remove(this);
-                    this.isQueued = false;
-                }
-            }
-            synchronized (pool.nonShutdownQueues) {
-                pool.nonShutdownQueues.remove(this);
-            }
-            synchronized (pool.activeQueues) {
-                pool.activeQueues.remove(this);
-            }
-        }
-
-        @Override
-        public boolean isActive() {
-            final PrioritisedThreadPool pool = this.pool;
-            final TreeSet<PrioritisedPoolExecutorImpl> queues = pool.queues;
-
-            synchronized (queues) {
-                if (this.concurrentExecutors != 0) {
-                    return true;
-                }
-                synchronized (pool.activeQueues) {
-                    if (pool.activeQueues.contains(this)) {
-                        return true;
-                    }
-                }
-            }
-
-            return false;
-        }
-
-        private long totalQueuedTasks = 0L;
-
-        @Override
-        protected void priorityChange(final PrioritisedThreadedTaskQueue.PrioritisedTask task, final Priority from, final Priority to) {
-            // Note: The superclass' queue lock is ALWAYS held when inside this method. So we do NOT need to do any additional synchronisation
-            // for accessing this queue's state.
-            final long[] priorityCounts = this.priorityCounts;
-            final boolean shutdown = this.isShutdown();
-
-            if (from == null && to == Priority.COMPLETING) {
-                throw new IllegalStateException("Cannot complete task without queueing it first");
-            }
-
-            // we should only notify for queueing of tasks, not changing priorities
-            final boolean shouldNotifyTasks = from == null;
-
-            final Priority scheduledPriority = this.scheduledPriority;
-            if (from != null) {
-                --priorityCounts[from.priority];
-            }
-            if (to != Priority.COMPLETING) {
-                ++priorityCounts[to.priority];
-            }
-            final long totalQueuedTasks;
-            if (to == Priority.COMPLETING) {
-                totalQueuedTasks = --this.totalQueuedTasks;
-            } else if (from == null) {
-                totalQueuedTasks = ++this.totalQueuedTasks;
-            } else {
-                totalQueuedTasks = this.totalQueuedTasks;
-            }
-
-            // find new highest priority
-            int highest = Math.min(to == Priority.COMPLETING ? Priority.IDLE.priority : to.priority, scheduledPriority == null ? Priority.IDLE.priority : scheduledPriority.priority);
-            int lowestPriority = priorityCounts.length; // exclusive
-            for (;highest < lowestPriority; ++highest) {
-                final long count = priorityCounts[highest];
-                if (count < 0) {
-                    throw new IllegalStateException("Priority " + highest + " has " + count + " scheduled tasks");
-                }
-
-                if (count != 0) {
-                    break;
-                }
-            }
-
-            final Priority newPriority;
-            if (highest == lowestPriority) {
-                // no tasks left
-                newPriority = null;
-            } else if (shutdown) {
-                // whichever is lower, the actual greatest priority or simply HIGHEST
-                // this is so shutdown automatically gets priority
-                newPriority = Priority.getPriority(Math.min(highest, Priority.HIGHEST.priority));
-            } else {
-                newPriority = Priority.getPriority(highest);
-            }
-
-            final int executorsWanted;
-            boolean shouldNotifyHighPriority = false;
-
-            final PrioritisedThreadPool pool = this.pool;
-            final TreeSet<PrioritisedPoolExecutorImpl> queues = pool.queues;
-
-            synchronized (queues) {
-                if (!this.isQueued) {
-                    // see if we need to be queued
-                    if (newPriority != null) {
-                        if (this.schedulingId == 0L) {
-                            this.schedulingId = ++pool.schedulingIdGenerator;
-                        }
-                        this.scheduledPriority = newPriority; // must be updated before queue add
-                        if (!this.isHalted && this.concurrentExecutors < this.maximumExecutors) {
-                            shouldNotifyHighPriority = newPriority.isHigherOrEqualPriority(Priority.HIGH);
-                            queues.add(this);
-                            this.isQueued = true;
-                        }
-                    } else {
-                        // do not queue
-                        this.scheduledPriority = null;
-                    }
-                } else {
-                    // see if we need to NOT be queued
-                    if (newPriority == null) {
-                        queues.remove(this);
-                        this.scheduledPriority = null;
-                        this.isQueued = false;
-                    } else if (scheduledPriority != newPriority) {
-                        // if our priority changed, we need to update it - which means removing and re-adding into the queue
-                        queues.remove(this);
-                        // only now can we update scheduledPriority, since we are no longer in queue
-                        this.scheduledPriority = newPriority;
-                        queues.add(this);
-                        shouldNotifyHighPriority = (scheduledPriority == null || scheduledPriority.isLowerPriority(Priority.HIGH)) && newPriority.isHigherOrEqualPriority(Priority.HIGH);
-                    }
-                }
-
-                if (this.isQueued) {
-                    executorsWanted = Math.min(this.maximumExecutors - this.concurrentExecutors, (int)totalQueuedTasks);
-                } else {
-                    executorsWanted = 0;
-                }
-            }
-
-            if (newPriority == null && shutdown) {
-                synchronized (pool.activeQueues) {
-                    pool.activeQueues.remove(this);
-                }
-            }
-
-            // Wake up the number of executors we want
-            if (executorsWanted > 0 || (shouldNotifyTasks | shouldNotifyHighPriority)) {
-                int notified = 0;
-                for (final PrioritisedThread thread : pool.threads) {
-                    if ((shouldNotifyHighPriority ? thread.alertHighPriorityExecutor() : thread.notifyTasks())
-                            && (++notified >= executorsWanted)) {
-                        break;
-                    }
-                }
-            }
-        }
-
-        @Override
-        public boolean shutdown() {
-            final boolean ret = super.shutdown();
-            if (!ret) {
-                return ret;
-            }
-
-            final PrioritisedThreadPool pool = this.pool;
-
-            // remove from active queues
-            synchronized (pool.nonShutdownQueues) {
-                pool.nonShutdownQueues.remove(this);
-            }
-
-            final TreeSet<PrioritisedPoolExecutorImpl> queues = pool.queues;
-
-            // try and shift around our priority
-            synchronized (queues) {
-                if (this.scheduledPriority == null) {
-                    // no tasks are queued, ensure we aren't in activeQueues
-                    synchronized (pool.activeQueues) {
-                        pool.activeQueues.remove(this);
-                    }
-
-                    return ret;
-                }
-
-                // try to set scheduled priority to HIGHEST so it drains faster
-
-                if (this.scheduledPriority.isHigherOrEqualPriority(Priority.HIGHEST)) {
-                    // already at target priority (highest or above)
-                    return ret;
-                }
-
-                // shift priority to HIGHEST
-
-                if (this.isQueued) {
-                    queues.remove(this);
-                    this.scheduledPriority = Priority.HIGHEST;
-                    queues.add(this);
-                } else {
-                    this.scheduledPriority = Priority.HIGHEST;
-                }
-            }
-
-            return ret;
-        }
-    }
-}
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedThreadedTaskQueue.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedThreadedTaskQueue.java
deleted file mode 100644
index 3e8401b1b1f833c4f01bc87059a2f48d761d989f..0000000000000000000000000000000000000000
--- a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedThreadedTaskQueue.java
+++ /dev/null
@@ -1,378 +0,0 @@
-package ca.spottedleaf.concurrentutil.executor.standard;
-
-import java.util.ArrayDeque;
-import java.util.concurrent.atomic.AtomicLong;
-
-public class PrioritisedThreadedTaskQueue implements PrioritisedExecutor {
-
-    protected final ArrayDeque<PrioritisedTask>[] queues = new ArrayDeque[Priority.TOTAL_SCHEDULABLE_PRIORITIES]; {
-        for (int i = 0; i < Priority.TOTAL_SCHEDULABLE_PRIORITIES; ++i) {
-            this.queues[i] = new ArrayDeque<>();
-        }
-    }
-
-    // Use AtomicLong to separate from the queue field, we don't want false sharing here.
-    protected final AtomicLong totalScheduledTasks = new AtomicLong();
-    protected final AtomicLong totalCompletedTasks = new AtomicLong();
-
-    // this is here to prevent failures to queue stalling flush() calls (as the schedule calls would increment totalScheduledTasks without this check)
-    protected volatile boolean hasShutdown;
-
-    protected long taskIdGenerator = 0;
-
-    @Override
-    public PrioritisedExecutor.PrioritisedTask queueRunnable(final Runnable task, final Priority priority) throws IllegalStateException, IllegalArgumentException {
-        if (!Priority.isValidPriority(priority)) {
-            throw new IllegalArgumentException("Priority " + priority + " is invalid");
-        }
-        if (task == null) {
-            throw new NullPointerException("Task cannot be null");
-        }
-
-        if (this.hasShutdown) {
-            // prevent us from stalling flush() calls by incrementing scheduled tasks when we really didn't schedule something
-            throw new IllegalStateException("Queue has shutdown");
-        }
-
-        final PrioritisedTask ret;
-
-        synchronized (this.queues) {
-            if (this.hasShutdown) {
-                throw new IllegalStateException("Queue has shutdown");
-            }
-            this.getAndAddTotalScheduledTasksVolatile(1L);
-
-            ret = new PrioritisedTask(this.taskIdGenerator++, task, priority, this);
-
-            this.queues[ret.priority.priority].add(ret);
-
-            // call priority change callback (note: only after we successfully queue!)
-            this.priorityChange(ret, null, priority);
-        }
-
-        return ret;
-    }
-
-    @Override
-    public PrioritisedExecutor.PrioritisedTask createTask(final Runnable task, final Priority priority) {
-        if (!Priority.isValidPriority(priority)) {
-            throw new IllegalArgumentException("Priority " + priority + " is invalid");
-        }
-        if (task == null) {
-            throw new NullPointerException("Task cannot be null");
-        }
-
-        return new PrioritisedTask(task, priority, this);
-    }
-
-    @Override
-    public long getTotalTasksScheduled() {
-        return this.totalScheduledTasks.get();
-    }
-
-    @Override
-    public long getTotalTasksExecuted() {
-        return this.totalCompletedTasks.get();
-    }
-
-    // callback method for subclasses to override
-    // from is null when a task is immediately created
-    protected void priorityChange(final PrioritisedTask task, final Priority from, final Priority to) {}
-
-    /**
-     * Polls the highest priority task currently available. {@code null} if none. This will mark the
-     * returned task as completed.
-     */
-    protected PrioritisedTask poll() {
-        return this.poll(Priority.IDLE);
-    }
-
-    protected PrioritisedTask poll(final Priority minPriority) {
-        final ArrayDeque<PrioritisedTask>[] queues = this.queues;
-        synchronized (queues) {
-            final int max = minPriority.priority;
-            for (int i = 0; i <= max; ++i) {
-                final ArrayDeque<PrioritisedTask> queue = queues[i];
-                PrioritisedTask task;
-                while ((task = queue.pollFirst()) != null) {
-                    if (task.trySetCompleting(i)) {
-                        return task;
-                    }
-                }
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Polls and executes the highest priority task currently available. Exceptions thrown during task execution will
-     * be rethrown.
-     * @return {@code true} if a task was executed, {@code false} otherwise.
-     */
-    @Override
-    public boolean executeTask() {
-        final PrioritisedTask task = this.poll();
-
-        if (task != null) {
-            task.executeInternal();
-            return true;
-        }
-
-        return false;
-    }
-
-    @Override
-    public boolean shutdown() {
-        synchronized (this.queues) {
-            if (this.hasShutdown) {
-                return false;
-            }
-            this.hasShutdown = true;
-        }
-        return true;
-    }
-
-    @Override
-    public boolean isShutdown() {
-        return this.hasShutdown;
-    }
-
-    /* totalScheduledTasks */
-
-    protected final long getTotalScheduledTasksVolatile() {
-        return this.totalScheduledTasks.get();
-    }
-
-    protected final long getAndAddTotalScheduledTasksVolatile(final long value) {
-        return this.totalScheduledTasks.getAndAdd(value);
-    }
-
-    /* totalCompletedTasks */
-
-    protected final long getTotalCompletedTasksVolatile() {
-        return this.totalCompletedTasks.get();
-    }
-
-    protected final long getAndAddTotalCompletedTasksVolatile(final long value) {
-        return this.totalCompletedTasks.getAndAdd(value);
-    }
-
-    protected static final class PrioritisedTask implements PrioritisedExecutor.PrioritisedTask {
-        protected final PrioritisedThreadedTaskQueue queue;
-        protected long id;
-        protected static final long NOT_SCHEDULED_ID = -1L;
-
-        protected Runnable runnable;
-        protected volatile Priority priority;
-
-        protected PrioritisedTask(final long id, final Runnable runnable, final Priority priority, final PrioritisedThreadedTaskQueue queue) {
-            if (!Priority.isValidPriority(priority)) {
-                throw new IllegalArgumentException("Invalid priority " + priority);
-            }
-
-            this.priority = priority;
-            this.runnable = runnable;
-            this.queue = queue;
-            this.id = id;
-        }
-
-        protected PrioritisedTask(final Runnable runnable, final Priority priority, final PrioritisedThreadedTaskQueue queue) {
-            if (!Priority.isValidPriority(priority)) {
-                throw new IllegalArgumentException("Invalid priority " + priority);
-            }
-
-            this.priority = priority;
-            this.runnable = runnable;
-            this.queue = queue;
-            this.id = NOT_SCHEDULED_ID;
-        }
-
-        @Override
-        public boolean queue() {
-            if (this.queue.hasShutdown) {
-                throw new IllegalStateException("Queue has shutdown");
-            }
-
-            synchronized (this.queue.queues) {
-                if (this.queue.hasShutdown) {
-                    throw new IllegalStateException("Queue has shutdown");
-                }
-
-                final Priority priority = this.priority;
-                if (priority == Priority.COMPLETING) {
-                    return false;
-                }
-
-                if (this.id != NOT_SCHEDULED_ID) {
-                    return false;
-                }
-
-                this.queue.getAndAddTotalScheduledTasksVolatile(1L);
-                this.id = this.queue.taskIdGenerator++;
-                this.queue.queues[priority.priority].add(this);
-
-                this.queue.priorityChange(this, null, priority);
-
-                return true;
-            }
-        }
-
-        protected boolean trySetCompleting(final int minPriority) {
-            final Priority oldPriority = this.priority;
-            if (oldPriority != Priority.COMPLETING && oldPriority.isHigherOrEqualPriority(minPriority)) {
-                this.priority = Priority.COMPLETING;
-                if (this.id != NOT_SCHEDULED_ID) {
-                    this.queue.priorityChange(this, oldPriority, Priority.COMPLETING);
-                }
-                return true;
-            }
-
-            return false;
-        }
-
-        @Override
-        public Priority getPriority() {
-            return this.priority;
-        }
-
-        @Override
-        public boolean setPriority(final Priority priority) {
-            if (!Priority.isValidPriority(priority)) {
-                throw new IllegalArgumentException("Invalid priority " + priority);
-            }
-            synchronized (this.queue.queues) {
-                final Priority curr = this.priority;
-
-                if (curr == Priority.COMPLETING) {
-                    return false;
-                }
-
-                if (curr == priority) {
-                    return true;
-                }
-
-                this.priority = priority;
-                if (this.id != NOT_SCHEDULED_ID) {
-                    this.queue.queues[priority.priority].add(this);
-
-                    // call priority change callback
-                    this.queue.priorityChange(this, curr, priority);
-                }
-            }
-
-            return true;
-        }
-
-        @Override
-        public boolean raisePriority(final Priority priority) {
-            if (!Priority.isValidPriority(priority)) {
-                throw new IllegalArgumentException("Invalid priority " + priority);
-            }
-
-            synchronized (this.queue.queues) {
-                final Priority curr = this.priority;
-
-                if (curr == Priority.COMPLETING) {
-                    return false;
-                }
-
-                if (curr.isHigherOrEqualPriority(priority)) {
-                    return true;
-                }
-
-                this.priority = priority;
-                if (this.id != NOT_SCHEDULED_ID) {
-                    this.queue.queues[priority.priority].add(this);
-
-                    // call priority change callback
-                    this.queue.priorityChange(this, curr, priority);
-                }
-            }
-
-            return true;
-        }
-
-        @Override
-        public boolean lowerPriority(final Priority priority) {
-            if (!Priority.isValidPriority(priority)) {
-                throw new IllegalArgumentException("Invalid priority " + priority);
-            }
-
-            synchronized (this.queue.queues) {
-                final Priority curr = this.priority;
-
-                if (curr == Priority.COMPLETING) {
-                    return false;
-                }
-
-                if (curr.isLowerOrEqualPriority(priority)) {
-                    return true;
-                }
-
-                this.priority = priority;
-                if (this.id != NOT_SCHEDULED_ID) {
-                    this.queue.queues[priority.priority].add(this);
-
-                    // call priority change callback
-                    this.queue.priorityChange(this, curr, priority);
-                }
-            }
-
-            return true;
-        }
-
-        @Override
-        public boolean cancel() {
-            final long id;
-            synchronized (this.queue.queues) {
-                final Priority oldPriority = this.priority;
-                if (oldPriority == Priority.COMPLETING) {
-                    return false;
-                }
-
-                this.priority = Priority.COMPLETING;
-                // call priority change callback
-                if ((id = this.id) != NOT_SCHEDULED_ID) {
-                    this.queue.priorityChange(this, oldPriority, Priority.COMPLETING);
-                }
-            }
-            this.runnable = null;
-            if (id != NOT_SCHEDULED_ID) {
-                this.queue.getAndAddTotalCompletedTasksVolatile(1L);
-            }
-            return true;
-        }
-
-        protected void executeInternal() {
-            try {
-                final Runnable execute = this.runnable;
-                this.runnable = null;
-                execute.run();
-            } finally {
-                if (this.id != NOT_SCHEDULED_ID) {
-                    this.queue.getAndAddTotalCompletedTasksVolatile(1L);
-                }
-            }
-        }
-
-        @Override
-        public boolean execute() {
-            synchronized (this.queue.queues) {
-                final Priority oldPriority = this.priority;
-                if (oldPriority == Priority.COMPLETING) {
-                    return false;
-                }
-
-                this.priority = Priority.COMPLETING;
-                // call priority change callback
-                if (this.id != NOT_SCHEDULED_ID) {
-                    this.queue.priorityChange(this, oldPriority, Priority.COMPLETING);
-                }
-            }
-
-            this.executeInternal();
-            return true;
-        }
-    }
-}
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedQueueExecutorThread.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/thread/PrioritisedQueueExecutorThread.java
similarity index 60%
rename from src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedQueueExecutorThread.java
rename to src/main/java/ca/spottedleaf/concurrentutil/executor/thread/PrioritisedQueueExecutorThread.java
index d1683ba6350e530373944f98192c0f2baf241e70..f5367a13aaa02f0f929813c00a67e6ac7c8652cb 100644
--- a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedQueueExecutorThread.java
+++ b/src/main/java/ca/spottedleaf/concurrentutil/executor/thread/PrioritisedQueueExecutorThread.java
@@ -1,6 +1,8 @@
-package ca.spottedleaf.concurrentutil.executor.standard;
+package ca.spottedleaf.concurrentutil.executor.thread;
 
+import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
 import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
+import ca.spottedleaf.concurrentutil.util.Priority;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import java.lang.invoke.VarHandle;
@@ -11,8 +13,7 @@ import java.util.concurrent.locks.LockSupport;
  * <p>
  *     Note: When using this thread, queue additions to the underlying {@link #queue} are not sufficient to get this thread
  *     to execute the task. The function {@link #notifyTasks()} must be used after scheduling a task. For expected behaviour
- *     of task scheduling (thread wakes up after tasks are scheduled), use the methods provided on {@link PrioritisedExecutor}
- *     methods.
+ *     of task scheduling, use the methods provided on this class to schedule tasks.
  * </p>
  */
 public class PrioritisedQueueExecutorThread extends Thread implements PrioritisedExecutor {
@@ -30,7 +31,7 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
 
     protected final long spinWaitTime;
 
-    static final long DEFAULT_SPINWAIT_TIME = (long)(0.1e6);// 0.1ms
+    protected static final long DEFAULT_SPINWAIT_TIME = (long)(0.1e6);// 0.1ms
 
     public PrioritisedQueueExecutorThread(final PrioritisedExecutor queue) {
         this(queue, DEFAULT_SPINWAIT_TIME); // 0.1ms
@@ -42,7 +43,16 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
     }
 
     @Override
-    public void run() {
+    public final void run() {
+        try {
+            this.begin();
+            this.doRun();
+        } finally {
+            this.die();
+        }
+    }
+
+    public final void doRun() {
         final long spinWaitTime = this.spinWaitTime;
 
         main_loop:
@@ -80,7 +90,7 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
             this.setThreadParkedVolatile(true);
 
             // We need to parse here to avoid a race condition where a thread queues a task before we set parked to true
-            // (i.e it will not notify us)
+            // (i.e. it will not notify us)
             if (this.pollTasks()) {
                 this.setThreadParkedVolatile(false);
                 continue;
@@ -99,6 +109,10 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
         }
     }
 
+    protected void begin() {}
+
+    protected void die() {}
+
     /**
      * Attempts to poll as many tasks as possible, returning when finished.
      * @return Whether any tasks were executed.
@@ -115,8 +129,6 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
                     break;
                 }
                 ret = true;
-            } catch (final ThreadDeath death) {
-                throw death; // goodbye world...
             } catch (final Throwable throwable) {
                 LOGGER.error("Exception thrown from prioritized runnable task in thread '" + this.getName() + "'", throwable);
             }
@@ -146,95 +158,86 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
     }
 
     @Override
-    public PrioritisedTask createTask(final Runnable task, final Priority priority) {
-        final PrioritisedTask queueTask = this.queue.createTask(task, priority);
-
-        // need to override queue() to notify us of tasks
-        return new PrioritisedTask() {
-            @Override
-            public Priority getPriority() {
-                return queueTask.getPriority();
-            }
-
-            @Override
-            public boolean setPriority(final Priority priority) {
-                return queueTask.setPriority(priority);
-            }
+    public long getTotalTasksExecuted() {
+        return this.queue.getTotalTasksExecuted();
+    }
 
-            @Override
-            public boolean raisePriority(final Priority priority) {
-                return queueTask.raisePriority(priority);
-            }
+    @Override
+    public long getTotalTasksScheduled() {
+        return this.queue.getTotalTasksScheduled();
+    }
 
-            @Override
-            public boolean lowerPriority(final Priority priority) {
-                return queueTask.lowerPriority(priority);
-            }
+    @Override
+    public long generateNextSubOrder() {
+        return this.queue.generateNextSubOrder();
+    }
 
-            @Override
-            public boolean queue() {
-                final boolean ret = queueTask.queue();
-                if (ret) {
-                    PrioritisedQueueExecutorThread.this.notifyTasks();
-                }
-                return ret;
-            }
+    @Override
+    public boolean shutdown() {
+        throw new UnsupportedOperationException();
+    }
 
-            @Override
-            public boolean cancel() {
-                return queueTask.cancel();
-            }
+    @Override
+    public boolean isShutdown() {
+        return false;
+    }
 
-            @Override
-            public boolean execute() {
-                return queueTask.execute();
-            }
-        };
+    /**
+     * {@inheritDoc}
+     * @throws IllegalStateException Always
+     */
+    @Override
+    public boolean executeTask() throws IllegalStateException {
+        throw new IllegalStateException();
     }
 
     @Override
-    public PrioritisedTask queueRunnable(final Runnable task, final Priority priority) {
-        final PrioritisedTask ret = this.queue.queueRunnable(task, priority);
+    public PrioritisedTask queueTask(final Runnable task) {
+        final PrioritisedTask ret = this.createTask(task);
 
-        this.notifyTasks();
+        ret.queue();
 
         return ret;
     }
 
     @Override
-    public boolean haveAllTasksExecuted() {
-        return this.queue.haveAllTasksExecuted();
+    public PrioritisedTask queueTask(final Runnable task, final Priority priority) {
+        final PrioritisedTask ret = this.createTask(task, priority);
+
+        ret.queue();
+
+        return ret;
     }
 
     @Override
-    public long getTotalTasksExecuted() {
-        return this.queue.getTotalTasksExecuted();
+    public PrioritisedTask queueTask(final Runnable task, final Priority priority, final long subOrder) {
+        final PrioritisedTask ret = this.createTask(task, priority, subOrder);
+
+        ret.queue();
+
+        return ret;
     }
 
+
     @Override
-    public long getTotalTasksScheduled() {
-        return this.queue.getTotalTasksScheduled();
+    public PrioritisedTask createTask(Runnable task) {
+        final PrioritisedTask queueTask = this.queue.createTask(task);
+
+        return new WrappedTask(queueTask);
     }
 
-    /**
-     * {@inheritDoc}
-     * @throws IllegalStateException If the current thread is {@code this} thread, or the underlying queue throws this exception.
-     */
     @Override
-    public void waitUntilAllExecuted() throws IllegalStateException {
-        if (Thread.currentThread() == this) {
-            throw new IllegalStateException("Cannot block on our own queue");
-        }
-        this.queue.waitUntilAllExecuted();
+    public PrioritisedTask createTask(final Runnable task, final Priority priority) {
+        final PrioritisedTask queueTask = this.queue.createTask(task, priority);
+
+        return new WrappedTask(queueTask);
     }
 
-    /**
-     * {@inheritDoc}
-     * @throws IllegalStateException Always
-     */
     @Override
-    public boolean executeTask() throws IllegalStateException {
-        throw new IllegalStateException();
+    public PrioritisedTask createTask(final Runnable task, final Priority priority, final long subOrder) {
+        final PrioritisedTask queueTask = this.queue.createTask(task, priority, subOrder);
+
+        return new WrappedTask(queueTask);
     }
 
     /**
@@ -242,7 +245,7 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
      * <p>
      *     This function is MT-Safe.
      * </p>
-     * @param wait If this call is to wait until the queue is empty and there are no tasks executing in the queue.
+     * @param wait If this call is to wait until this thread shuts down.
      * @param killQueue Whether to shutdown this thread's queue
      * @return whether this thread shut down the queue
      * @see #halt(boolean)
@@ -256,7 +259,20 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
         LockSupport.unpark(this);
 
         if (wait) {
-            this.waitUntilAllExecuted();
+            boolean interrupted = false;
+            for (;;) {
+                if (this.isAlive()) {
+                    if (interrupted) {
+                        Thread.currentThread().interrupt();
+                    }
+                    break;
+                }
+                try {
+                    this.join();
+                } catch (final InterruptedException ex) {
+                    interrupted = true;
+                }
+            }
         }
 
         return ret;
@@ -298,4 +314,89 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
     protected final void setThreadParkedVolatile(final boolean value) {
         THREAD_PARKED_HANDLE.setVolatile(this, value);
     }
+
+    /**
+     * Required so that queue() can notify (unpark) this thread
+     */
+    private final class WrappedTask implements PrioritisedTask {
+        private final PrioritisedTask queueTask;
+
+        public WrappedTask(final PrioritisedTask queueTask) {
+            this.queueTask = queueTask;
+        }
+
+        @Override
+        public PrioritisedExecutor getExecutor() {
+            return PrioritisedQueueExecutorThread.this;
+        }
+
+        @Override
+        public boolean queue() {
+            final boolean ret = this.queueTask.queue();
+            if (ret) {
+                PrioritisedQueueExecutorThread.this.notifyTasks();
+            }
+            return ret;
+        }
+
+        @Override
+        public boolean isQueued() {
+            return this.queueTask.isQueued();
+        }
+
+        @Override
+        public boolean cancel() {
+            return this.queueTask.cancel();
+        }
+
+        @Override
+        public boolean execute() {
+            return this.queueTask.execute();
+        }
+
+        @Override
+        public Priority getPriority() {
+            return this.queueTask.getPriority();
+        }
+
+        @Override
+        public boolean setPriority(final Priority priority) {
+            return this.queueTask.setPriority(priority);
+        }
+
+        @Override
+        public boolean raisePriority(final Priority priority) {
+            return this.queueTask.raisePriority(priority);
+        }
+
+        @Override
+        public boolean lowerPriority(final Priority priority) {
+            return this.queueTask.lowerPriority(priority);
+        }
+
+        @Override
+        public long getSubOrder() {
+            return this.queueTask.getSubOrder();
+        }
+
+        @Override
+        public boolean setSubOrder(final long subOrder) {
+            return this.queueTask.setSubOrder(subOrder);
+        }
+
+        @Override
+        public boolean raiseSubOrder(final long subOrder) {
+            return this.queueTask.raiseSubOrder(subOrder);
+        }
+
+        @Override
+        public boolean lowerSubOrder(final long subOrder) {
+            return this.queueTask.lowerSubOrder(subOrder);
+        }
+
+        @Override
+        public boolean setPriorityAndSubOrder(final Priority priority, final long subOrder) {
+            return this.queueTask.setPriorityAndSubOrder(priority, subOrder);
+        }
+    }
 }
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/thread/PrioritisedThreadPool.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/thread/PrioritisedThreadPool.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb9df914a9a6d0d3f58fa58d8c93f4f583416cd1
--- /dev/null
+++ b/src/main/java/ca/spottedleaf/concurrentutil/executor/thread/PrioritisedThreadPool.java
@@ -0,0 +1,741 @@
+package ca.spottedleaf.concurrentutil.executor.thread;
+
+import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
+import ca.spottedleaf.concurrentutil.executor.queue.PrioritisedTaskQueue;
+import ca.spottedleaf.concurrentutil.util.Priority;
+import ca.spottedleaf.concurrentutil.util.TimeUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Consumer;
+
+public final class PrioritisedThreadPool {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(PrioritisedThreadPool.class);
+
+    private final Consumer<Thread> threadModifier;
+    private final COWArrayList<ExecutorGroup> executors = new COWArrayList<>(ExecutorGroup.class);
+    private final COWArrayList<PrioritisedThread> threads = new COWArrayList<>(PrioritisedThread.class);
+    private final COWArrayList<PrioritisedThread> aliveThreads = new COWArrayList<>(PrioritisedThread.class);
+
+    private static final Priority HIGH_PRIORITY_NOTIFY_THRESHOLD = Priority.HIGH;
+    private static final Priority QUEUE_SHUTDOWN_PRIORITY = Priority.HIGH;
+
+    private boolean shutdown;
+
+    public PrioritisedThreadPool(final Consumer<Thread> threadModifier) {
+        this.threadModifier = threadModifier;
+
+        if (threadModifier == null) {
+            throw new NullPointerException("Thread factory may not be null");
+        }
+    }
+
+    public Thread[] getAliveThreads() {
+        final PrioritisedThread[] threads = this.aliveThreads.getArray();
+
+        return Arrays.copyOf(threads, threads.length, Thread[].class);
+    }
+
+    public Thread[] getCoreThreads() {
+        final PrioritisedThread[] threads = this.threads.getArray();
+
+        return Arrays.copyOf(threads, threads.length, Thread[].class);
+    }
+
+    /**
+     * Prevents creation of new queues, shutdowns all non-shutdown queues if specified
+     */
+    public void halt(final boolean shutdownQueues) {
+        synchronized (this) {
+            this.shutdown = true;
+        }
+
+        if (shutdownQueues) {
+            for (final ExecutorGroup group : this.executors.getArray()) {
+                for (final ExecutorGroup.ThreadPoolExecutor executor : group.executors.getArray()) {
+                    executor.shutdown();
+                }
+            }
+        }
+
+        for (final PrioritisedThread thread : this.threads.getArray()) {
+            thread.halt(false);
+        }
+    }
+
+    /**
+     * Waits until all threads in this pool have shutdown, or until the specified time has passed.
+     * @param msToWait Maximum time to wait.
+     * @return {@code false} if the maximum time passed, {@code true} otherwise.
+     */
+    public boolean join(final long msToWait) {
+        try {
+            return this.join(msToWait, false);
+        } catch (final InterruptedException ex) {
+            throw new IllegalStateException(ex);
+        }
+    }
+
+    /**
+     * Waits until all threads in this pool have shutdown, or until the specified time has passed.
+     * @param msToWait Maximum time to wait.
+     * @return {@code false} if the maximum time passed, {@code true} otherwise.
+     * @throws InterruptedException If this thread is interrupted.
+     */
+    public boolean joinInterruptable(final long msToWait) throws InterruptedException {
+        return this.join(msToWait, true);
+    }
+
+    protected final boolean join(final long msToWait, final boolean interruptable) throws InterruptedException {
+        final long nsToWait = msToWait * (1000 * 1000);
+        final long start = System.nanoTime();
+        final long deadline = start + nsToWait;
+        boolean interrupted = false;
+        try {
+            for (final PrioritisedThread thread : this.aliveThreads.getArray()) {
+                for (;;) {
+                    if (!thread.isAlive()) {
+                        break;
+                    }
+                    final long current = System.nanoTime();
+                    if (current >= deadline && msToWait > 0L) {
+                        return false;
+                    }
+
+                    try {
+                        thread.join(msToWait <= 0L ? 0L : Math.max(1L, (deadline - current) / (1000 * 1000)));
+                    } catch (final InterruptedException ex) {
+                        if (interruptable) {
+                            throw ex;
+                        }
+                        interrupted = true;
+                    }
+                }
+            }
+
+            return true;
+        } finally {
+            if (interrupted) {
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
+
+    /**
+     * Shuts down this thread pool, optionally waiting for all tasks to be executed.
+     * This function will invoke {@link PrioritisedExecutor#shutdown()} on all created executors on this
+     * thread pool.
+     * @param wait Whether to wait for tasks to be executed
+     */
+    public void shutdown(final boolean wait) {
+        synchronized (this) {
+            this.shutdown = true;
+        }
+
+        for (final ExecutorGroup group : this.executors.getArray()) {
+            for (final ExecutorGroup.ThreadPoolExecutor executor : group.executors.getArray()) {
+                executor.shutdown();
+            }
+        }
+
+
+        for (final PrioritisedThread thread : this.threads.getArray()) {
+            // none of these can be true or else NPE
+            thread.close(false, false);
+        }
+
+        if (wait) {
+            this.join(0L);
+        }
+    }
+
+    private void die(final PrioritisedThread thread) {
+        this.aliveThreads.remove(thread);
+    }
+
+    public void adjustThreadCount(final int threads) {
+        synchronized (this) {
+            if (this.shutdown) {
+                return;
+            }
+
+            final PrioritisedThread[] currentThreads = this.threads.getArray();
+            if (threads == currentThreads.length) {
+                // no adjustment needed
+                return;
+            }
+
+            if (threads < currentThreads.length) {
+                // we need to trim threads
+                for (int i = 0, difference = currentThreads.length - threads; i < difference; ++i) {
+                    final PrioritisedThread remove = currentThreads[currentThreads.length - i - 1];
+
+                    remove.halt(false);
+                    this.threads.remove(remove);
+                }
+            } else {
+                // we need to add threads
+                for (int i = 0, difference = threads - currentThreads.length; i < difference; ++i) {
+                    final PrioritisedThread thread = new PrioritisedThread();
+
+                    this.threadModifier.accept(thread);
+                    this.aliveThreads.add(thread);
+                    this.threads.add(thread);
+
+                    thread.start();
+                }
+            }
+        }
+    }
+
+    private static int compareInsideGroup(final ExecutorGroup.ThreadPoolExecutor src, final Priority srcPriority,
+                                          final ExecutorGroup.ThreadPoolExecutor dst, final Priority dstPriority) {
+        final int priorityCompare = srcPriority.ordinal() - dstPriority.ordinal();
+        if (priorityCompare != 0) {
+            return priorityCompare;
+        }
+
+        final int parallelismCompare = src.currentParallelism - dst.currentParallelism;
+        if (parallelismCompare != 0) {
+            return parallelismCompare;
+        }
+
+        return TimeUtil.compareTimes(src.lastRetrieved, dst.lastRetrieved);
+    }
+
+    private static int compareOutsideGroup(final ExecutorGroup.ThreadPoolExecutor src, final Priority srcPriority,
+                                           final ExecutorGroup.ThreadPoolExecutor dst, final Priority dstPriority) {
+        if (src.getGroup().division == dst.getGroup().division) {
+            // can only compare priorities inside the same division
+            final int priorityCompare = srcPriority.ordinal() - dstPriority.ordinal();
+            if (priorityCompare != 0) {
+                return priorityCompare;
+            }
+        }
+
+        final int parallelismCompare = src.getGroup().currentParallelism - dst.getGroup().currentParallelism;
+        if (parallelismCompare != 0) {
+            return parallelismCompare;
+        }
+
+        return TimeUtil.compareTimes(src.lastRetrieved, dst.lastRetrieved);
+    }
+
+    private ExecutorGroup.ThreadPoolExecutor obtainQueue() {
+        final long time = System.nanoTime();
+        synchronized (this) {
+            ExecutorGroup.ThreadPoolExecutor ret = null;
+            Priority retPriority = null;
+
+            for (final ExecutorGroup executorGroup : this.executors.getArray()) {
+                ExecutorGroup.ThreadPoolExecutor highest = null;
+                Priority highestPriority = null;
+                for (final ExecutorGroup.ThreadPoolExecutor executor : executorGroup.executors.getArray()) {
+                    final int maxParallelism = executor.maxParallelism;
+                    if (maxParallelism > 0 && executor.currentParallelism >= maxParallelism) {
+                        continue;
+                    }
+
+                    final Priority priority = executor.getTargetPriority();
+
+                    if (priority == null) {
+                        continue;
+                    }
+
+                    if (highestPriority == null || compareInsideGroup(highest, highestPriority, executor, priority) > 0) {
+                        highest = executor;
+                        highestPriority = priority;
+                    }
+                }
+
+                if (highest == null) {
+                    continue;
+                }
+
+                if (ret == null || compareOutsideGroup(ret, retPriority, highest, highestPriority) > 0) {
+                    ret = highest;
+                    retPriority = highestPriority;
+                }
+            }
+
+            if (ret != null) {
+                ret.lastRetrieved = time;
+                ++ret.currentParallelism;
+                ++ret.getGroup().currentParallelism;
+                return ret;
+            }
+
+            return ret;
+        }
+    }
+
+    private void returnQueue(final ExecutorGroup.ThreadPoolExecutor executor) {
+        synchronized (this) {
+            --executor.currentParallelism;
+            --executor.getGroup().currentParallelism;
+        }
+
+        if (executor.isShutdown() && executor.queue.hasNoScheduledTasks()) {
+            executor.getGroup().executors.remove(executor);
+        }
+    }
+
+    private void notifyAllThreads() {
+        for (final PrioritisedThread thread : this.threads.getArray()) {
+            thread.notifyTasks();
+        }
+    }
+
+    public ExecutorGroup createExecutorGroup(final int division, final int flags) {
+        synchronized (this) {
+            if (this.shutdown) {
+                throw new IllegalStateException("Queue is shutdown: " + this.toString());
+            }
+
+            final ExecutorGroup ret = new ExecutorGroup(division, flags);
+
+            this.executors.add(ret);
+
+            return ret;
+        }
+    }
+
+    private final class PrioritisedThread extends PrioritisedQueueExecutorThread {
+
+        private final AtomicBoolean alertedHighPriority = new AtomicBoolean();
+
+        public PrioritisedThread() {
+            super(null);
+        }
+
+        public boolean alertHighPriorityExecutor() {
+            if (!this.notifyTasks()) {
+                if (!this.alertedHighPriority.get()) {
+                    this.alertedHighPriority.set(true);
+                }
+                return false;
+            }
+
+            return true;
+        }
+
+        private boolean isAlertedHighPriority() {
+            return this.alertedHighPriority.get() && this.alertedHighPriority.getAndSet(false);
+        }
+
+        @Override
+        protected void die() {
+            PrioritisedThreadPool.this.die(this);
+        }
+
+        @Override
+        protected boolean pollTasks() {
+            boolean ret = false;
+
+            for (;;) {
+                if (this.halted) {
+                    break;
+                }
+
+                final ExecutorGroup.ThreadPoolExecutor executor = PrioritisedThreadPool.this.obtainQueue();
+                if (executor == null) {
+                    break;
+                }
+                final long deadline = System.nanoTime() + executor.queueMaxHoldTime;
+                do {
+                    try {
+                        if (this.halted || executor.halt) {
+                            break;
+                        }
+                        if (!executor.executeTask()) {
+                            // no more tasks, try next queue
+                            break;
+                        }
+                        ret = true;
+                    } catch (final Throwable throwable) {
+                        LOGGER.error("Exception thrown from thread '" + this.getName() + "' in queue '" + executor.toString() + "'", throwable);
+                    }
+                } while (!this.isAlertedHighPriority() && System.nanoTime() <= deadline);
+
+                PrioritisedThreadPool.this.returnQueue(executor);
+            }
+
+
+            return ret;
+        }
+    }
+
+    public final class ExecutorGroup {
+
+        private final AtomicLong subOrderGenerator = new AtomicLong();
+        private final COWArrayList<ThreadPoolExecutor> executors = new COWArrayList<>(ThreadPoolExecutor.class);
+
+        private final int division;
+        private int currentParallelism;
+
+        private ExecutorGroup(final int division, final int flags) {
+            this.division = division;
+        }
+
+        public ThreadPoolExecutor[] getAllExecutors() {
+            return this.executors.getArray().clone();
+        }
+
+        private PrioritisedThreadPool getThreadPool() {
+            return PrioritisedThreadPool.this;
+        }
+
+        public ThreadPoolExecutor createExecutor(final int maxParallelism, final long queueMaxHoldTime, final int flags) {
+            synchronized (PrioritisedThreadPool.this) {
+                if (PrioritisedThreadPool.this.shutdown) {
+                    throw new IllegalStateException("Queue is shutdown: " + PrioritisedThreadPool.this.toString());
+                }
+
+                final ThreadPoolExecutor ret = new ThreadPoolExecutor(maxParallelism, queueMaxHoldTime, flags);
+
+                this.executors.add(ret);
+
+                return ret;
+            }
+        }
+
+        public final class ThreadPoolExecutor implements PrioritisedExecutor {
+
+            private final PrioritisedTaskQueue queue = new PrioritisedTaskQueue();
+
+            private volatile int maxParallelism;
+            private final long queueMaxHoldTime;
+            private volatile int currentParallelism;
+            private volatile boolean halt;
+            private long lastRetrieved = System.nanoTime();
+
+            private ThreadPoolExecutor(final int maxParallelism, final long queueMaxHoldTime, final int flags) {
+                this.maxParallelism = maxParallelism;
+                this.queueMaxHoldTime = queueMaxHoldTime;
+            }
+
+            private ExecutorGroup getGroup() {
+                return ExecutorGroup.this;
+            }
+
+            private boolean canNotify() {
+                if (this.halt) {
+                    return false;
+                }
+
+                final int max = this.maxParallelism;
+                return max < 0 || this.currentParallelism < max;
+            }
+
+            private void notifyHighPriority() {
+                if (!this.canNotify()) {
+                    return;
+                }
+                for (final PrioritisedThread thread : this.getGroup().getThreadPool().threads.getArray()) {
+                    if (thread.alertHighPriorityExecutor()) {
+                        return;
+                    }
+                }
+            }
+
+            private void notifyScheduled() {
+                if (!this.canNotify()) {
+                    return;
+                }
+                for (final PrioritisedThread thread : this.getGroup().getThreadPool().threads.getArray()) {
+                    if (thread.notifyTasks()) {
+                        return;
+                    }
+                }
+            }
+
+            /**
+             * Removes this queue from the thread pool without shutting the queue down or waiting for queued tasks to be executed
+             */
+            public void halt() {
+                this.halt = true;
+
+                ExecutorGroup.this.executors.remove(this);
+            }
+
+            /**
+             * Returns whether this executor is scheduled to run tasks or is running tasks, otherwise it returns whether
+             * this queue is not halted and not shutdown.
+             */
+            public boolean isActive() {
+                if (this.halt) {
+                    return this.currentParallelism > 0;
+                } else {
+                    if (!this.isShutdown()) {
+                        return true;
+                    }
+
+                    return !this.queue.hasNoScheduledTasks();
+                }
+            }
+
+            @Override
+            public boolean shutdown() {
+                if (!this.queue.shutdown()) {
+                    return false;
+                }
+
+                if (this.queue.hasNoScheduledTasks()) {
+                    ExecutorGroup.this.executors.remove(this);
+                }
+
+                return true;
+            }
+
+            @Override
+            public boolean isShutdown() {
+                return this.queue.isShutdown();
+            }
+
+            public void setMaxParallelism(final int maxParallelism) {
+                this.maxParallelism = maxParallelism;
+                // assume that we could have increased the parallelism
+                if (this.getTargetPriority() != null) {
+                    ExecutorGroup.this.getThreadPool().notifyAllThreads();
+                }
+            }
+
+            Priority getTargetPriority() {
+                final Priority ret = this.queue.getHighestPriority();
+                if (!this.isShutdown()) {
+                    return ret;
+                }
+
+                return ret == null ? QUEUE_SHUTDOWN_PRIORITY : Priority.max(ret, QUEUE_SHUTDOWN_PRIORITY);
+            }
+
+            @Override
+            public long getTotalTasksScheduled() {
+                return this.queue.getTotalTasksScheduled();
+            }
+
+            @Override
+            public long getTotalTasksExecuted() {
+                return this.queue.getTotalTasksExecuted();
+            }
+
+            @Override
+            public long generateNextSubOrder() {
+                return ExecutorGroup.this.subOrderGenerator.getAndIncrement();
+            }
+
+            @Override
+            public boolean executeTask() {
+                return this.queue.executeTask();
+            }
+
+            @Override
+            public PrioritisedTask queueTask(final Runnable task) {
+                final PrioritisedTask ret = this.createTask(task);
+
+                ret.queue();
+
+                return ret;
+            }
+
+            @Override
+            public PrioritisedTask queueTask(final Runnable task, final Priority priority) {
+                final PrioritisedTask ret = this.createTask(task, priority);
+
+                ret.queue();
+
+                return ret;
+            }
+
+            @Override
+            public PrioritisedTask queueTask(final Runnable task, final Priority priority, final long subOrder) {
+                final PrioritisedTask ret = this.createTask(task, priority, subOrder);
+
+                ret.queue();
+
+                return ret;
+            }
+
+            @Override
+            public PrioritisedTask createTask(final Runnable task) {
+                return this.createTask(task, Priority.NORMAL);
+            }
+
+            @Override
+            public PrioritisedTask createTask(final Runnable task, final Priority priority) {
+                return this.createTask(task, priority, this.generateNextSubOrder());
+            }
+
+            @Override
+            public PrioritisedTask createTask(final Runnable task, final Priority priority, final long subOrder) {
+                return new WrappedTask(this.queue.createTask(task, priority, subOrder));
+            }
+
+            private final class WrappedTask implements PrioritisedTask {
+
+                private final PrioritisedTask wrapped;
+
+                private WrappedTask(final PrioritisedTask wrapped) {
+                    this.wrapped = wrapped;
+                }
+
+                @Override
+                public PrioritisedExecutor getExecutor() {
+                    return ThreadPoolExecutor.this;
+                }
+
+                @Override
+                public boolean queue() {
+                    if (this.wrapped.queue()) {
+                        final Priority priority = this.getPriority();
+                        if (priority != Priority.COMPLETING) {
+                            if (priority.isHigherOrEqualPriority(HIGH_PRIORITY_NOTIFY_THRESHOLD)) {
+                                ThreadPoolExecutor.this.notifyHighPriority();
+                            } else {
+                                ThreadPoolExecutor.this.notifyScheduled();
+                            }
+                        }
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                @Override
+                public boolean isQueued() {
+                    return this.wrapped.isQueued();
+                }
+
+                @Override
+                public boolean cancel() {
+                    return this.wrapped.cancel();
+                }
+
+                @Override
+                public boolean execute() {
+                    return this.wrapped.execute();
+                }
+
+                @Override
+                public Priority getPriority() {
+                    return this.wrapped.getPriority();
+                }
+
+                @Override
+                public boolean setPriority(final Priority priority) {
+                    if (this.wrapped.setPriority(priority)) {
+                        if (priority.isHigherOrEqualPriority(HIGH_PRIORITY_NOTIFY_THRESHOLD)) {
+                            ThreadPoolExecutor.this.notifyHighPriority();
+                        }
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                @Override
+                public boolean raisePriority(final Priority priority) {
+                    if (this.wrapped.raisePriority(priority)) {
+                        if (priority.isHigherOrEqualPriority(HIGH_PRIORITY_NOTIFY_THRESHOLD)) {
+                            ThreadPoolExecutor.this.notifyHighPriority();
+                        }
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                @Override
+                public boolean lowerPriority(final Priority priority) {
+                    return this.wrapped.lowerPriority(priority);
+                }
+
+                @Override
+                public long getSubOrder() {
+                    return this.wrapped.getSubOrder();
+                }
+
+                @Override
+                public boolean setSubOrder(final long subOrder) {
+                    return this.wrapped.setSubOrder(subOrder);
+                }
+
+                @Override
+                public boolean raiseSubOrder(final long subOrder) {
+                    return this.wrapped.raiseSubOrder(subOrder);
+                }
+
+                @Override
+                public boolean lowerSubOrder(final long subOrder) {
+                    return this.wrapped.lowerSubOrder(subOrder);
+                }
+
+                @Override
+                public boolean setPriorityAndSubOrder(final Priority priority, final long subOrder) {
+                    if (this.wrapped.setPriorityAndSubOrder(priority, subOrder)) {
+                        if (priority.isHigherOrEqualPriority(HIGH_PRIORITY_NOTIFY_THRESHOLD)) {
+                            ThreadPoolExecutor.this.notifyHighPriority();
+                        }
+                        return true;
+                    }
+
+                    return false;
+                }
+            }
+        }
+    }
+
+    private static final class COWArrayList<E> {
+
+        private volatile E[] array;
+
+        public COWArrayList(final Class<E> clazz) {
+            this.array = (E[])Array.newInstance(clazz, 0);
+        }
+
+        public E[] getArray() {
+            return this.array;
+        }
+
+        public void add(final E element) {
+            synchronized (this) {
+                final E[] array = this.array;
+
+                final E[] copy = Arrays.copyOf(array, array.length + 1);
+                copy[array.length] = element;
+
+                this.array = copy;
+            }
+        }
+
+        public boolean remove(final E element) {
+            synchronized (this) {
+                final E[] array = this.array;
+                int index = -1;
+                for (int i = 0, len = array.length; i < len; ++i) {
+                    if (array[i] == element) {
+                        index = i;
+                        break;
+                    }
+                }
+
+                if (index == -1) {
+                    return false;
+                }
+
+                final E[] copy = (E[])Array.newInstance(array.getClass().getComponentType(), array.length - 1);
+
+                System.arraycopy(array, 0, copy, 0, index);
+                System.arraycopy(array, index + 1, copy, index, (array.length - 1) - index);
+
+                this.array = copy;
+            }
+
+            return true;
+        }
+    }
+}
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/map/ConcurrentLong2ReferenceChainedHashTable.java b/src/main/java/ca/spottedleaf/concurrentutil/map/ConcurrentLong2ReferenceChainedHashTable.java
index d701998b376579ec652fb94823befa3cc0bc4090..6918f130099e6c19e20a47bfdb54915cdd13732a 100644
--- a/src/main/java/ca/spottedleaf/concurrentutil/map/ConcurrentLong2ReferenceChainedHashTable.java
+++ b/src/main/java/ca/spottedleaf/concurrentutil/map/ConcurrentLong2ReferenceChainedHashTable.java
@@ -43,7 +43,7 @@ import java.util.function.Predicate;
  * @param <V>
  * @see java.util.concurrent.ConcurrentMap
  */
-public class ConcurrentLong2ReferenceChainedHashTable<V> {
+public class ConcurrentLong2ReferenceChainedHashTable<V> implements Iterable<ConcurrentLong2ReferenceChainedHashTable.TableEntry<V>> {
 
     protected static final int DEFAULT_CAPACITY = 16;
     protected static final float DEFAULT_LOAD_FACTOR = 0.75f;
@@ -192,6 +192,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
             }
 
             if (node.resize) {
+                // noinspection unchecked
                 table = (TableEntry<V>[])node.getValuePlain();
                 continue;
             }
@@ -274,10 +275,10 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
     public int size() {
         final long ret = this.size.sum();
 
-        if (ret <= 0L) {
+        if (ret < 0L) {
             return 0;
         }
-        if (ret >= (long)Integer.MAX_VALUE) {
+        if (ret > (long)Integer.MAX_VALUE) {
             return Integer.MAX_VALUE;
         }
 
@@ -341,6 +342,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
 
         // create new table data
 
+        // noinspection unchecked
         final TableEntry<V>[] newTable = new TableEntry[capacity];
         // noinspection unchecked
         final TableEntry<V> resizeNode = new TableEntry<>(0L, (V)newTable, true);
@@ -365,6 +367,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
             throw new IllegalStateException("Resizing to same size");
         }
 
+        // noinspection unchecked
         final TableEntry<V>[] work = new TableEntry[1 << capDiffShift]; // typically, capDiffShift = 1
 
         for (int i = 0, len = oldTable.length; i < len; ++i) {
@@ -538,6 +541,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
                 }
 
                 if (node.resize) {
+                    // noinspection unchecked
                     table = (TableEntry<V>[])node.getValuePlain();
                     continue table_loop;
                 }
@@ -599,6 +603,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
                 }
 
                 if (node.resize) {
+                    // noinspection unchecked
                     table = (TableEntry<V>[])node.getValuePlain();
                     continue table_loop;
                 }
@@ -653,6 +658,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
                 }
 
                 if (node.resize) {
+                    // noinspection unchecked
                     table = (TableEntry<V>[])node.getValuePlain();
                     continue table_loop;
                 }
@@ -704,6 +710,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
                 }
 
                 if (node.resize) {
+                    // noinspection unchecked
                     table = (TableEntry<V>[])node.getValuePlain();
                     continue table_loop;
                 }
@@ -772,6 +779,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
                 }
 
                 if (node.resize) {
+                    // noinspection unchecked
                     table = (TableEntry<V>[])node.getValuePlain();
                     continue table_loop;
                 }
@@ -848,6 +856,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
                 }
 
                 if (node.resize) {
+                    // noinspection unchecked
                     table = (TableEntry<V>[])node.getValuePlain();
                     continue table_loop;
                 }
@@ -944,6 +953,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
                 }
 
                 if (node.resize) {
+                    // noinspection unchecked
                     table = (TableEntry<V>[])node.getValuePlain();
                     continue table_loop;
                 }
@@ -1058,6 +1068,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
                 }
 
                 if (node.resize) {
+                    // noinspection unchecked
                     table = (TableEntry<V>[])node.getValuePlain();
                     continue table_loop;
                 }
@@ -1126,6 +1137,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
                 }
 
                 if (node.resize) {
+                    // noinspection unchecked
                     table = (TableEntry<V>[])node.getValuePlain();
                     continue table_loop;
                 }
@@ -1200,6 +1212,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
                 }
 
                 if (node.resize) {
+                    // noinspection unchecked
                     table = (TableEntry<V>[])node.getValuePlain();
                     continue table_loop;
                 }
@@ -1288,6 +1301,11 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
         return new EntryIterator<>(this);
     }
 
+    @Override
+    public final Iterator<TableEntry<V>> iterator() {
+        return this.entryIterator();
+    }
+
     /**
      * Returns an iterator over the keys in this map. The iterator is only guaranteed to see keys that were
      * added before the beginning of this call, but it may see keys added during.
@@ -1306,7 +1324,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
 
     protected static final class EntryIterator<V> extends BaseIteratorImpl<V, TableEntry<V>> {
 
-        protected EntryIterator(final ConcurrentLong2ReferenceChainedHashTable<V> map) {
+        public EntryIterator(final ConcurrentLong2ReferenceChainedHashTable<V> map) {
             super(map);
         }
 
@@ -1326,7 +1344,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
 
     protected static final class KeyIterator<V> extends BaseIteratorImpl<V, Long> implements PrimitiveIterator.OfLong {
 
-        protected KeyIterator(final ConcurrentLong2ReferenceChainedHashTable<V> map) {
+        public KeyIterator(final ConcurrentLong2ReferenceChainedHashTable<V> map) {
             super(map);
         }
 
@@ -1365,7 +1383,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
 
     protected static final class ValueIterator<V> extends BaseIteratorImpl<V, V> {
 
-        protected ValueIterator(final ConcurrentLong2ReferenceChainedHashTable<V> map) {
+        public ValueIterator(final ConcurrentLong2ReferenceChainedHashTable<V> map) {
             super(map);
         }
 
@@ -1420,7 +1438,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
 
         @Override
         public final void remove() {
-            final TableEntry<V> lastReturned = this.nextToReturn;
+            final TableEntry<V> lastReturned = this.lastReturned;
             if (lastReturned == null) {
                 throw new NoSuchElementException();
             }
@@ -1492,6 +1510,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
             final ResizeChain<V> chain = this.resizeChain;
 
             if (chain == null) {
+                // noinspection unchecked
                 final TableEntry<V>[] nextTable = (TableEntry<V>[])entry.getValuePlain();
 
                 final ResizeChain<V> oldChain = new ResizeChain<>(table, null, null);
@@ -1506,6 +1525,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
             } else {
                 ResizeChain<V> currChain = chain.next;
                 if (currChain == null) {
+                    // noinspection unchecked
                     final TableEntry<V>[] ret = (TableEntry<V>[])entry.getValuePlain();
                     currChain = new ResizeChain<>(ret, chain, null);
                     chain.next = currChain;
@@ -1586,11 +1606,11 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
 
         protected static final class ResizeChain<V> {
 
-            protected final TableEntry<V>[] table;
-            protected final ResizeChain<V> prev;
-            protected ResizeChain<V> next;
+            public final TableEntry<V>[] table;
+            public final ResizeChain<V> prev;
+            public ResizeChain<V> next;
 
-            protected ResizeChain(final TableEntry<V>[] table, final ResizeChain<V> prev, final ResizeChain<V> next) {
+            public ResizeChain(final TableEntry<V>[] table, final ResizeChain<V> prev, final ResizeChain<V> next) {
                 this.table = table;
                 this.prev = prev;
                 this.next = next;
@@ -1600,64 +1620,64 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
 
     public static final class TableEntry<V> {
 
-        protected static final VarHandle TABLE_ENTRY_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(TableEntry[].class);
+        private static final VarHandle TABLE_ENTRY_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(TableEntry[].class);
 
-        protected final boolean resize;
+        private final boolean resize;
 
-        protected final long key;
+        private final long key;
 
-        protected volatile V value;
-        protected static final VarHandle VALUE_HANDLE = ConcurrentUtil.getVarHandle(TableEntry.class, "value", Object.class);
+        private volatile V value;
+        private static final VarHandle VALUE_HANDLE = ConcurrentUtil.getVarHandle(TableEntry.class, "value", Object.class);
 
-        protected final V getValuePlain() {
+        private V getValuePlain() {
             //noinspection unchecked
             return (V)VALUE_HANDLE.get(this);
         }
 
-        protected final V getValueAcquire() {
+        private V getValueAcquire() {
             //noinspection unchecked
             return (V)VALUE_HANDLE.getAcquire(this);
         }
 
-        protected final V getValueVolatile() {
+        private V getValueVolatile() {
             //noinspection unchecked
             return (V)VALUE_HANDLE.getVolatile(this);
         }
 
-        protected final void setValuePlain(final V value) {
+        private void setValuePlain(final V value) {
             VALUE_HANDLE.set(this, (Object)value);
         }
 
-        protected final void setValueRelease(final V value) {
+        private void setValueRelease(final V value) {
             VALUE_HANDLE.setRelease(this, (Object)value);
         }
 
-        protected final void setValueVolatile(final V value) {
+        private void setValueVolatile(final V value) {
             VALUE_HANDLE.setVolatile(this, (Object)value);
         }
 
-        protected volatile TableEntry<V> next;
-        protected static final VarHandle NEXT_HANDLE = ConcurrentUtil.getVarHandle(TableEntry.class, "next", TableEntry.class);
+        private volatile TableEntry<V> next;
+        private static final VarHandle NEXT_HANDLE = ConcurrentUtil.getVarHandle(TableEntry.class, "next", TableEntry.class);
 
-        protected final TableEntry<V> getNextPlain() {
+        private TableEntry<V> getNextPlain() {
             //noinspection unchecked
             return (TableEntry<V>)NEXT_HANDLE.get(this);
         }
 
-        protected final TableEntry<V> getNextVolatile() {
+        private TableEntry<V> getNextVolatile() {
             //noinspection unchecked
             return (TableEntry<V>)NEXT_HANDLE.getVolatile(this);
         }
 
-        protected final void setNextPlain(final TableEntry<V> next) {
+        private void setNextPlain(final TableEntry<V> next) {
             NEXT_HANDLE.set(this, next);
         }
 
-        protected final void setNextRelease(final TableEntry<V> next) {
+        private void setNextRelease(final TableEntry<V> next) {
             NEXT_HANDLE.setRelease(this, next);
         }
 
-        protected final void setNextVolatile(final TableEntry<V> next) {
+        private void setNextVolatile(final TableEntry<V> next) {
             NEXT_HANDLE.setVolatile(this, next);
         }
 
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/scheduler/SchedulerThreadPool.java b/src/main/java/ca/spottedleaf/concurrentutil/scheduler/SchedulerThreadPool.java
index 8197ccb1c4e5878dbd8007b5fb514640765ec8e4..85e6ef636d435a0ee4bf3e0760b0c87422c520a1 100644
--- a/src/main/java/ca/spottedleaf/concurrentutil/scheduler/SchedulerThreadPool.java
+++ b/src/main/java/ca/spottedleaf/concurrentutil/scheduler/SchedulerThreadPool.java
@@ -13,6 +13,10 @@ import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.locks.LockSupport;
 import java.util.function.BooleanSupplier;
 
+/**
+ * @deprecated To be replaced
+ */
+@Deprecated
 public class SchedulerThreadPool {
 
     public static final long DEADLINE_NOT_SET = Long.MIN_VALUE;
@@ -297,7 +301,9 @@ public class SchedulerThreadPool {
      * is invoked for any scheduled task - otherwise, {@link #runTasks(BooleanSupplier)} may not be invoked to
      * parse intermediate tasks.
      * </p>
+     * @deprecated To be replaced
      */
+    @Deprecated
     public static abstract class SchedulableTick {
         private static final AtomicLong ID_GENERATOR = new AtomicLong();
         public final long id = ID_GENERATOR.getAndIncrement();
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/set/LinkedSortedSet.java b/src/main/java/ca/spottedleaf/concurrentutil/set/LinkedSortedSet.java
index 212bc9ae2fc7d37d4a089a2921b00de1e97f7cc1..82c4c11b0b564c97ac92bd5f54e3754a7ba95184 100644
--- a/src/main/java/ca/spottedleaf/concurrentutil/set/LinkedSortedSet.java
+++ b/src/main/java/ca/spottedleaf/concurrentutil/set/LinkedSortedSet.java
@@ -8,8 +8,8 @@ public final class LinkedSortedSet<E> implements Iterable<E> {
 
     public final Comparator<? super E> comparator;
 
-    protected Link<E> head;
-    protected Link<E> tail;
+    private Link<E> head;
+    private Link<E> tail;
 
     public LinkedSortedSet() {
         this((Comparator)Comparator.naturalOrder());
@@ -257,8 +257,6 @@ public final class LinkedSortedSet<E> implements Iterable<E> {
         private Link<E> prev;
         private Link<E> next;
 
-        private Link() {}
-
         private Link(final E element) {
             this.element = element;
         }
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/set/LinkedUnsortedList.java b/src/main/java/ca/spottedleaf/concurrentutil/set/LinkedUnsortedList.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd8eb4f25d1dee00fbf9c05c14b0d94c5c641a55
--- /dev/null
+++ b/src/main/java/ca/spottedleaf/concurrentutil/set/LinkedUnsortedList.java
@@ -0,0 +1,204 @@
+package ca.spottedleaf.concurrentutil.set;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+
+public final class LinkedUnsortedList<E> implements Iterable<E> {
+
+    private Link<E> head;
+    private Link<E> tail;
+
+    public LinkedUnsortedList() {}
+
+    public void clear() {
+        this.head = this.tail = null;
+    }
+
+    public boolean isEmpty() {
+        return this.head == null;
+    }
+
+    public E first() {
+        final Link<E> head = this.head;
+        return head == null ? null : head.element;
+    }
+
+    public E last() {
+        final Link<E> tail = this.tail;
+        return tail == null ? null : tail.element;
+    }
+
+    public boolean containsFirst(final E element) {
+        for (Link<E> curr = this.head; curr != null; curr = curr.next) {
+            if (Objects.equals(element, curr.element)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean containsLast(final E element) {
+        for (Link<E> curr = this.tail; curr != null; curr = curr.prev) {
+            if (Objects.equals(element, curr.element)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private void removeNode(final Link<E> node) {
+        final Link<E> prev = node.prev;
+        final Link<E> next = node.next;
+
+        // help GC
+        node.element = null;
+        node.prev = null;
+        node.next = null;
+
+        if (prev == null) {
+            this.head = next;
+        } else {
+            prev.next = next;
+        }
+
+        if (next == null) {
+            this.tail = prev;
+        } else {
+            next.prev = prev;
+        }
+    }
+
+    public boolean remove(final Link<E> link) {
+        if (link.element == null) {
+            return false;
+        }
+
+        this.removeNode(link);
+        return true;
+    }
+
+    public boolean removeFirst(final E element) {
+        for (Link<E> curr = this.head; curr != null; curr = curr.next) {
+            if (Objects.equals(element, curr.element)) {
+                this.removeNode(curr);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean removeLast(final E element) {
+        for (Link<E> curr = this.tail; curr != null; curr = curr.prev) {
+            if (Objects.equals(element, curr.element)) {
+                this.removeNode(curr);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public Iterator<E> iterator() {
+        return new Iterator<>() {
+            private Link<E> next = LinkedUnsortedList.this.head;
+
+            @Override
+            public boolean hasNext() {
+                return this.next != null;
+            }
+
+            @Override
+            public E next() {
+                final Link<E> next = this.next;
+                if (next == null) {
+                    throw new NoSuchElementException();
+                }
+                this.next = next.next;
+                return next.element;
+            }
+        };
+    }
+
+    public E pollFirst() {
+        final Link<E> head = this.head;
+        if (head == null) {
+            return null;
+        }
+
+        final E ret = head.element;
+        final Link<E> next = head.next;
+
+        // unlink head
+        this.head = next;
+        if (next == null) {
+            this.tail = null;
+        } else {
+            next.prev = null;
+        }
+
+        // help GC
+        head.element = null;
+        head.next = null;
+
+        return ret;
+    }
+
+    public E pollLast() {
+        final Link<E> tail = this.tail;
+        if (tail == null) {
+            return null;
+        }
+
+        final E ret = tail.element;
+        final Link<E> prev = tail.prev;
+
+        // unlink tail
+        this.tail = prev;
+        if (prev == null) {
+            this.head = null;
+        } else {
+            prev.next = null;
+        }
+
+        // help GC
+        tail.element = null;
+        tail.prev = null;
+
+        return ret;
+    }
+
+    public Link<E> addLast(final E element) {
+        final Link<E> curr = this.tail;
+        if (curr != null) {
+            return this.tail = new Link<>(element, curr, null);
+        } else {
+            return this.head = this.tail = new Link<>(element);
+        }
+    }
+
+    public Link<E> addFirst(final E element) {
+        final Link<E> curr = this.head;
+        if (curr != null) {
+            return this.head = new Link<>(element, null, curr);
+        } else {
+            return this.head = this.tail = new Link<>(element);
+        }
+    }
+
+    public static final class Link<E> {
+        private E element;
+        private Link<E> prev;
+        private Link<E> next;
+
+        private Link(final E element) {
+            this.element = element;
+        }
+
+        private Link(final E element, final Link<E> prev, final Link<E> next) {
+            this.element = element;
+            this.prev = prev;
+            this.next = next;
+        }
+    }
+}
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/util/ArrayUtil.java b/src/main/java/ca/spottedleaf/concurrentutil/util/ArrayUtil.java
deleted file mode 100644
index ebb1ab06165addb173fea4d295001fe37f4e79d3..0000000000000000000000000000000000000000
--- a/src/main/java/ca/spottedleaf/concurrentutil/util/ArrayUtil.java
+++ /dev/null
@@ -1,816 +0,0 @@
-package ca.spottedleaf.concurrentutil.util;
-
-import java.lang.invoke.VarHandle;
-
-public final class ArrayUtil {
-
-    public static final VarHandle BOOLEAN_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(boolean[].class);
-
-    public static final VarHandle BYTE_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(byte[].class);
-
-    public static final VarHandle SHORT_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(short[].class);
-
-    public static final VarHandle INT_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(int[].class);
-
-    public static final VarHandle LONG_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(long[].class);
-
-    public static final VarHandle OBJECT_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(Object[].class);
-
-    private ArrayUtil() {
-        throw new RuntimeException();
-    }
-
-    /* byte array */
-
-    public static byte getPlain(final byte[] array, final int index) {
-        return (byte)BYTE_ARRAY_HANDLE.get(array, index);
-    }
-
-    public static byte getOpaque(final byte[] array, final int index) {
-        return (byte)BYTE_ARRAY_HANDLE.getOpaque(array, index);
-    }
-
-    public static byte getAcquire(final byte[] array, final int index) {
-        return (byte)BYTE_ARRAY_HANDLE.getAcquire(array, index);
-    }
-
-    public static byte getVolatile(final byte[] array, final int index) {
-        return (byte)BYTE_ARRAY_HANDLE.getVolatile(array, index);
-    }
-
-    public static void setPlain(final byte[] array, final int index, final byte value) {
-        BYTE_ARRAY_HANDLE.set(array, index, value);
-    }
-
-    public static void setOpaque(final byte[] array, final int index, final byte value) {
-        BYTE_ARRAY_HANDLE.setOpaque(array, index, value);
-    }
-
-    public static void setRelease(final byte[] array, final int index, final byte value) {
-        BYTE_ARRAY_HANDLE.setRelease(array, index, value);
-    }
-
-    public static void setVolatile(final byte[] array, final int index, final byte value) {
-        BYTE_ARRAY_HANDLE.setVolatile(array, index, value);
-    }
-
-    public static void setVolatileContended(final byte[] array, final int index, final byte param) {
-        int failures = 0;
-
-        for (byte curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
-                return;
-            }
-        }
-    }
-
-    public static byte compareAndExchangeVolatile(final byte[] array, final int index, final byte expect, final byte update) {
-        return (byte)BYTE_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
-    }
-
-    public static byte getAndAddVolatile(final byte[] array, final int index, final byte param) {
-        return (byte)BYTE_ARRAY_HANDLE.getAndAdd(array, index, param);
-    }
-
-    public static byte getAndAndVolatile(final byte[] array, final int index, final byte param) {
-        return (byte)BYTE_ARRAY_HANDLE.getAndBitwiseAnd(array, index, param);
-    }
-
-    public static byte getAndOrVolatile(final byte[] array, final int index, final byte param) {
-        return (byte)BYTE_ARRAY_HANDLE.getAndBitwiseOr(array, index, param);
-    }
-
-    public static byte getAndXorVolatile(final byte[] array, final int index, final byte param) {
-        return (byte)BYTE_ARRAY_HANDLE.getAndBitwiseXor(array, index, param);
-    }
-
-    public static byte getAndSetVolatile(final byte[] array, final int index, final byte param) {
-        return (byte)BYTE_ARRAY_HANDLE.getAndSet(array, index, param);
-    }
-
-    public static byte compareAndExchangeVolatileContended(final byte[] array, final int index, final byte expect, final byte update) {
-        return (byte)BYTE_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
-    }
-
-    public static byte getAndAddVolatileContended(final byte[] array, final int index, final byte param) {
-        int failures = 0;
-
-        for (byte curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (byte) (curr + param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static byte getAndAndVolatileContended(final byte[] array, final int index, final byte param) {
-        int failures = 0;
-
-        for (byte curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (byte) (curr & param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static byte getAndOrVolatileContended(final byte[] array, final int index, final byte param) {
-        int failures = 0;
-
-        for (byte curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (byte) (curr | param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static byte getAndXorVolatileContended(final byte[] array, final int index, final byte param) {
-        int failures = 0;
-
-        for (byte curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (byte) (curr ^ param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static byte getAndSetVolatileContended(final byte[] array, final int index, final byte param) {
-        int failures = 0;
-
-        for (byte curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
-                return curr;
-            }
-        }
-    }
-
-    /* short array */
-
-    public static short getPlain(final short[] array, final int index) {
-        return (short)SHORT_ARRAY_HANDLE.get(array, index);
-    }
-
-    public static short getOpaque(final short[] array, final int index) {
-        return (short)SHORT_ARRAY_HANDLE.getOpaque(array, index);
-    }
-
-    public static short getAcquire(final short[] array, final int index) {
-        return (short)SHORT_ARRAY_HANDLE.getAcquire(array, index);
-    }
-
-    public static short getVolatile(final short[] array, final int index) {
-        return (short)SHORT_ARRAY_HANDLE.getVolatile(array, index);
-    }
-
-    public static void setPlain(final short[] array, final int index, final short value) {
-        SHORT_ARRAY_HANDLE.set(array, index, value);
-    }
-
-    public static void setOpaque(final short[] array, final int index, final short value) {
-        SHORT_ARRAY_HANDLE.setOpaque(array, index, value);
-    }
-
-    public static void setRelease(final short[] array, final int index, final short value) {
-        SHORT_ARRAY_HANDLE.setRelease(array, index, value);
-    }
-
-    public static void setVolatile(final short[] array, final int index, final short value) {
-        SHORT_ARRAY_HANDLE.setVolatile(array, index, value);
-    }
-
-    public static void setVolatileContended(final short[] array, final int index, final short param) {
-        int failures = 0;
-
-        for (short curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
-                return;
-            }
-        }
-    }
-
-    public static short compareAndExchangeVolatile(final short[] array, final int index, final short expect, final short update) {
-        return (short)SHORT_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
-    }
-
-    public static short getAndAddVolatile(final short[] array, final int index, final short param) {
-        return (short)SHORT_ARRAY_HANDLE.getAndAdd(array, index, param);
-    }
-
-    public static short getAndAndVolatile(final short[] array, final int index, final short param) {
-        return (short)SHORT_ARRAY_HANDLE.getAndBitwiseAnd(array, index, param);
-    }
-
-    public static short getAndOrVolatile(final short[] array, final int index, final short param) {
-        return (short)SHORT_ARRAY_HANDLE.getAndBitwiseOr(array, index, param);
-    }
-
-    public static short getAndXorVolatile(final short[] array, final int index, final short param) {
-        return (short)SHORT_ARRAY_HANDLE.getAndBitwiseXor(array, index, param);
-    }
-
-    public static short getAndSetVolatile(final short[] array, final int index, final short param) {
-        return (short)SHORT_ARRAY_HANDLE.getAndSet(array, index, param);
-    }
-
-    public static short compareAndExchangeVolatileContended(final short[] array, final int index, final short expect, final short update) {
-        return (short)SHORT_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
-    }
-
-    public static short getAndAddVolatileContended(final short[] array, final int index, final short param) {
-        int failures = 0;
-
-        for (short curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (short) (curr + param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static short getAndAndVolatileContended(final short[] array, final int index, final short param) {
-        int failures = 0;
-
-        for (short curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (short) (curr & param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static short getAndOrVolatileContended(final short[] array, final int index, final short param) {
-        int failures = 0;
-
-        for (short curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (short) (curr | param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static short getAndXorVolatileContended(final short[] array, final int index, final short param) {
-        int failures = 0;
-
-        for (short curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (short) (curr ^ param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static short getAndSetVolatileContended(final short[] array, final int index, final short param) {
-        int failures = 0;
-
-        for (short curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
-                return curr;
-            }
-        }
-    }
-
-    /* int array */
-
-    public static int getPlain(final int[] array, final int index) {
-        return (int)INT_ARRAY_HANDLE.get(array, index);
-    }
-
-    public static int getOpaque(final int[] array, final int index) {
-        return (int)INT_ARRAY_HANDLE.getOpaque(array, index);
-    }
-
-    public static int getAcquire(final int[] array, final int index) {
-        return (int)INT_ARRAY_HANDLE.getAcquire(array, index);
-    }
-
-    public static int getVolatile(final int[] array, final int index) {
-        return (int)INT_ARRAY_HANDLE.getVolatile(array, index);
-    }
-
-    public static void setPlain(final int[] array, final int index, final int value) {
-        INT_ARRAY_HANDLE.set(array, index, value);
-    }
-
-    public static void setOpaque(final int[] array, final int index, final int value) {
-        INT_ARRAY_HANDLE.setOpaque(array, index, value);
-    }
-
-    public static void setRelease(final int[] array, final int index, final int value) {
-        INT_ARRAY_HANDLE.setRelease(array, index, value);
-    }
-
-    public static void setVolatile(final int[] array, final int index, final int value) {
-        INT_ARRAY_HANDLE.setVolatile(array, index, value);
-    }
-
-    public static void setVolatileContended(final int[] array, final int index, final int param) {
-        int failures = 0;
-
-        for (int curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
-                return;
-            }
-        }
-    }
-
-    public static int compareAndExchangeVolatile(final int[] array, final int index, final int expect, final int update) {
-        return (int)INT_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
-    }
-
-    public static int getAndAddVolatile(final int[] array, final int index, final int param) {
-        return (int)INT_ARRAY_HANDLE.getAndAdd(array, index, param);
-    }
-
-    public static int getAndAndVolatile(final int[] array, final int index, final int param) {
-        return (int)INT_ARRAY_HANDLE.getAndBitwiseAnd(array, index, param);
-    }
-
-    public static int getAndOrVolatile(final int[] array, final int index, final int param) {
-        return (int)INT_ARRAY_HANDLE.getAndBitwiseOr(array, index, param);
-    }
-
-    public static int getAndXorVolatile(final int[] array, final int index, final int param) {
-        return (int)INT_ARRAY_HANDLE.getAndBitwiseXor(array, index, param);
-    }
-
-    public static int getAndSetVolatile(final int[] array, final int index, final int param) {
-        return (int)INT_ARRAY_HANDLE.getAndSet(array, index, param);
-    }
-
-    public static int compareAndExchangeVolatileContended(final int[] array, final int index, final int expect, final int update) {
-        return (int)INT_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
-    }
-
-    public static int getAndAddVolatileContended(final int[] array, final int index, final int param) {
-        int failures = 0;
-
-        for (int curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (int) (curr + param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static int getAndAndVolatileContended(final int[] array, final int index, final int param) {
-        int failures = 0;
-
-        for (int curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (int) (curr & param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static int getAndOrVolatileContended(final int[] array, final int index, final int param) {
-        int failures = 0;
-
-        for (int curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (int) (curr | param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static int getAndXorVolatileContended(final int[] array, final int index, final int param) {
-        int failures = 0;
-
-        for (int curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (int) (curr ^ param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static int getAndSetVolatileContended(final int[] array, final int index, final int param) {
-        int failures = 0;
-
-        for (int curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
-                return curr;
-            }
-        }
-    }
-
-    /* long array */
-
-    public static long getPlain(final long[] array, final int index) {
-        return (long)LONG_ARRAY_HANDLE.get(array, index);
-    }
-
-    public static long getOpaque(final long[] array, final int index) {
-        return (long)LONG_ARRAY_HANDLE.getOpaque(array, index);
-    }
-
-    public static long getAcquire(final long[] array, final int index) {
-        return (long)LONG_ARRAY_HANDLE.getAcquire(array, index);
-    }
-
-    public static long getVolatile(final long[] array, final int index) {
-        return (long)LONG_ARRAY_HANDLE.getVolatile(array, index);
-    }
-
-    public static void setPlain(final long[] array, final int index, final long value) {
-        LONG_ARRAY_HANDLE.set(array, index, value);
-    }
-
-    public static void setOpaque(final long[] array, final int index, final long value) {
-        LONG_ARRAY_HANDLE.setOpaque(array, index, value);
-    }
-
-    public static void setRelease(final long[] array, final int index, final long value) {
-        LONG_ARRAY_HANDLE.setRelease(array, index, value);
-    }
-
-    public static void setVolatile(final long[] array, final int index, final long value) {
-        LONG_ARRAY_HANDLE.setVolatile(array, index, value);
-    }
-
-    public static void setVolatileContended(final long[] array, final int index, final long param) {
-        int failures = 0;
-
-        for (long curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
-                return;
-            }
-        }
-    }
-
-    public static long compareAndExchangeVolatile(final long[] array, final int index, final long expect, final long update) {
-        return (long)LONG_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
-    }
-
-    public static long getAndAddVolatile(final long[] array, final int index, final long param) {
-        return (long)LONG_ARRAY_HANDLE.getAndAdd(array, index, param);
-    }
-
-    public static long getAndAndVolatile(final long[] array, final int index, final long param) {
-        return (long)LONG_ARRAY_HANDLE.getAndBitwiseAnd(array, index, param);
-    }
-
-    public static long getAndOrVolatile(final long[] array, final int index, final long param) {
-        return (long)LONG_ARRAY_HANDLE.getAndBitwiseOr(array, index, param);
-    }
-
-    public static long getAndXorVolatile(final long[] array, final int index, final long param) {
-        return (long)LONG_ARRAY_HANDLE.getAndBitwiseXor(array, index, param);
-    }
-
-    public static long getAndSetVolatile(final long[] array, final int index, final long param) {
-        return (long)LONG_ARRAY_HANDLE.getAndSet(array, index, param);
-    }
-
-    public static long compareAndExchangeVolatileContended(final long[] array, final int index, final long expect, final long update) {
-        return (long)LONG_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
-    }
-
-    public static long getAndAddVolatileContended(final long[] array, final int index, final long param) {
-        int failures = 0;
-
-        for (long curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (long) (curr + param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static long getAndAndVolatileContended(final long[] array, final int index, final long param) {
-        int failures = 0;
-
-        for (long curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (long) (curr & param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static long getAndOrVolatileContended(final long[] array, final int index, final long param) {
-        int failures = 0;
-
-        for (long curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (long) (curr | param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static long getAndXorVolatileContended(final long[] array, final int index, final long param) {
-        int failures = 0;
-
-        for (long curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (long) (curr ^ param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static long getAndSetVolatileContended(final long[] array, final int index, final long param) {
-        int failures = 0;
-
-        for (long curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
-                return curr;
-            }
-        }
-    }
-
-    /* boolean array */
-
-    public static boolean getPlain(final boolean[] array, final int index) {
-        return (boolean)BOOLEAN_ARRAY_HANDLE.get(array, index);
-    }
-
-    public static boolean getOpaque(final boolean[] array, final int index) {
-        return (boolean)BOOLEAN_ARRAY_HANDLE.getOpaque(array, index);
-    }
-
-    public static boolean getAcquire(final boolean[] array, final int index) {
-        return (boolean)BOOLEAN_ARRAY_HANDLE.getAcquire(array, index);
-    }
-
-    public static boolean getVolatile(final boolean[] array, final int index) {
-        return (boolean)BOOLEAN_ARRAY_HANDLE.getVolatile(array, index);
-    }
-
-    public static void setPlain(final boolean[] array, final int index, final boolean value) {
-        BOOLEAN_ARRAY_HANDLE.set(array, index, value);
-    }
-
-    public static void setOpaque(final boolean[] array, final int index, final boolean value) {
-        BOOLEAN_ARRAY_HANDLE.setOpaque(array, index, value);
-    }
-
-    public static void setRelease(final boolean[] array, final int index, final boolean value) {
-        BOOLEAN_ARRAY_HANDLE.setRelease(array, index, value);
-    }
-
-    public static void setVolatile(final boolean[] array, final int index, final boolean value) {
-        BOOLEAN_ARRAY_HANDLE.setVolatile(array, index, value);
-    }
-
-    public static void setVolatileContended(final boolean[] array, final int index, final boolean param) {
-        int failures = 0;
-
-        for (boolean curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
-                return;
-            }
-        }
-    }
-
-    public static boolean compareAndExchangeVolatile(final boolean[] array, final int index, final boolean expect, final boolean update) {
-        return (boolean)BOOLEAN_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
-    }
-
-    public static boolean getAndOrVolatile(final boolean[] array, final int index, final boolean param) {
-        return (boolean)BOOLEAN_ARRAY_HANDLE.getAndBitwiseOr(array, index, param);
-    }
-
-    public static boolean getAndXorVolatile(final boolean[] array, final int index, final boolean param) {
-        return (boolean)BOOLEAN_ARRAY_HANDLE.getAndBitwiseXor(array, index, param);
-    }
-
-    public static boolean getAndSetVolatile(final boolean[] array, final int index, final boolean param) {
-        return (boolean)BOOLEAN_ARRAY_HANDLE.getAndSet(array, index, param);
-    }
-
-    public static boolean compareAndExchangeVolatileContended(final boolean[] array, final int index, final boolean expect, final boolean update) {
-        return (boolean)BOOLEAN_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
-    }
-
-    public static boolean getAndAndVolatileContended(final boolean[] array, final int index, final boolean param) {
-        int failures = 0;
-
-        for (boolean curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (boolean) (curr & param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static boolean getAndOrVolatileContended(final boolean[] array, final int index, final boolean param) {
-        int failures = 0;
-
-        for (boolean curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (boolean) (curr | param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static boolean getAndXorVolatileContended(final boolean[] array, final int index, final boolean param) {
-        int failures = 0;
-
-        for (boolean curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (boolean) (curr ^ param)))) {
-                return curr;
-            }
-        }
-    }
-
-    public static boolean getAndSetVolatileContended(final boolean[] array, final int index, final boolean param) {
-        int failures = 0;
-
-        for (boolean curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
-                return curr;
-            }
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    public static <T> T getPlain(final T[] array, final int index) {
-        final Object ret = OBJECT_ARRAY_HANDLE.get((Object[])array, index);
-        return (T)ret;
-    }
-
-    @SuppressWarnings("unchecked")
-    public static <T> T getOpaque(final T[] array, final int index) {
-        final Object ret = OBJECT_ARRAY_HANDLE.getOpaque((Object[])array, index);
-        return (T)ret;
-    }
-
-    @SuppressWarnings("unchecked")
-    public static <T> T getAcquire(final T[] array, final int index) {
-        final Object ret = OBJECT_ARRAY_HANDLE.getAcquire((Object[])array, index);
-        return (T)ret;
-    }
-
-    @SuppressWarnings("unchecked")
-    public static <T> T getVolatile(final T[] array, final int index) {
-        final Object ret = OBJECT_ARRAY_HANDLE.getVolatile((Object[])array, index);
-        return (T)ret;
-    }
-
-    public static <T> void setPlain(final T[] array, final int index, final T value) {
-        OBJECT_ARRAY_HANDLE.set((Object[])array, index, (Object)value);
-    }
-
-    public static <T> void setOpaque(final T[] array, final int index, final T value) {
-        OBJECT_ARRAY_HANDLE.setOpaque((Object[])array, index, (Object)value);
-    }
-
-    public static <T> void setRelease(final T[] array, final int index, final T value) {
-        OBJECT_ARRAY_HANDLE.setRelease((Object[])array, index, (Object)value);
-    }
-
-    public static <T> void setVolatile(final T[] array, final int index, final T value) {
-        OBJECT_ARRAY_HANDLE.setVolatile((Object[])array, index, (Object)value);
-    }
-
-    public static <T> void setVolatileContended(final T[] array, final int index, final T param) {
-        int failures = 0;
-
-        for (T curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
-                return;
-            }
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    public static <T> T compareAndExchangeVolatile(final T[] array, final int index, final T expect, final T update) {
-        final Object ret = OBJECT_ARRAY_HANDLE.compareAndExchange((Object[])array, index, (Object)expect, (Object)update);
-        return (T)ret;
-    }
-
-    @SuppressWarnings("unchecked")
-    public static <T> T getAndSetVolatile(final T[] array, final int index, final T param) {
-        final Object ret = BYTE_ARRAY_HANDLE.getAndSet((Object[])array, index, (Object)param);
-        return (T)ret;
-    }
-
-    @SuppressWarnings("unchecked")
-    public static <T> T compareAndExchangeVolatileContended(final T[] array, final int index, final T expect, final T update) {
-        final Object ret = OBJECT_ARRAY_HANDLE.compareAndExchange((Object[])array, index, (Object)expect, (Object)update);
-        return (T)ret;
-    }
-
-    public static <T> T getAndSetVolatileContended(final T[] array, final int index, final T param) {
-        int failures = 0;
-
-        for (T curr = getVolatile(array, index);;++failures) {
-            for (int i = 0; i < failures; ++i) {
-                ConcurrentUtil.backoff();
-            }
-
-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
-                return curr;
-            }
-        }
-    }
-}
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/util/IntegerUtil.java b/src/main/java/ca/spottedleaf/concurrentutil/util/IntegerUtil.java
index 77699c5fa9681f9ec7aa05cbb50eb60828e193ab..9d7b9b8158cd01d12adbd7896ff77bee9828e101 100644
--- a/src/main/java/ca/spottedleaf/concurrentutil/util/IntegerUtil.java
+++ b/src/main/java/ca/spottedleaf/concurrentutil/util/IntegerUtil.java
@@ -170,6 +170,26 @@ public final class IntegerUtil {
         return (mask ^ val) - mask; // if val < 0, then (0 ^ val) - 0 else (-1 ^ val) + 1
     }
 
+    // https://lemire.me/blog/2019/02/08/faster-remainders-when-the-divisor-is-a-constant-beating-compilers-and-libdivide
+    /**
+     *
+     * Usage:
+     * <pre>
+     * {@code
+     *     static final long mult = getSimpleMultiplier(divisor, bits);
+     *     long x = ...;
+     *     long magic = x * mult;
+     *     long divQ = magic >>> bits;
+     *     long divR = ((magic & ((1 << bits) - 1)) * divisor) >>> bits;
+     * }
+     * </pre>
+     *
+     * @param bits The number of bits of precision for the returned result
+     */
+    public static long getUnsignedDivisorMagic(final long divisor, final int bits) {
+        return (((1L << bits) - 1L) / divisor) + 1;
+    }
+
     private IntegerUtil() {
         throw new RuntimeException();
     }
diff --git a/src/main/java/ca/spottedleaf/concurrentutil/util/Priority.java b/src/main/java/ca/spottedleaf/concurrentutil/util/Priority.java
new file mode 100644
index 0000000000000000000000000000000000000000..2919bbaa07b70f182438c3be8f9ebbe0649809b6
--- /dev/null
+++ b/src/main/java/ca/spottedleaf/concurrentutil/util/Priority.java
@@ -0,0 +1,145 @@
+package ca.spottedleaf.concurrentutil.util;
+
+public enum Priority {
+
+    /**
+     * Priority value indicating the task has completed or is being completed.
+     * This priority cannot be used to schedule tasks.
+     */
+    COMPLETING(-1),
+
+    /**
+     * Absolute highest priority, should only be used for when a task is blocking a time-critical thread.
+     */
+    BLOCKING(),
+
+    /**
+     * Should only be used for urgent but not time-critical tasks.
+     */
+    HIGHEST(),
+
+    /**
+     * Two priorities above normal.
+     */
+    HIGHER(),
+
+    /**
+     * One priority above normal.
+     */
+    HIGH(),
+
+    /**
+     * Default priority.
+     */
+    NORMAL(),
+
+    /**
+     * One priority below normal.
+     */
+    LOW(),
+
+    /**
+     * Two priorities below normal.
+     */
+    LOWER(),
+
+    /**
+     * Use for tasks that should eventually execute, but are not needed to.
+     */
+    LOWEST(),
+
+    /**
+     * Use for tasks that can be delayed indefinitely.
+     */
+    IDLE();
+
+    // returns whether the priority can be scheduled
+    public static boolean isValidPriority(final Priority priority) {
+        return priority != null && priority != priority.COMPLETING;
+    }
+
+    // returns the higher priority of the two
+    public static Priority max(final Priority p1, final Priority p2) {
+        return p1.isHigherOrEqualPriority(p2) ? p1 : p2;
+    }
+
+    // returns the lower priroity of the two
+    public static Priority min(final Priority p1, final Priority p2) {
+        return p1.isLowerOrEqualPriority(p2) ? p1 : p2;
+    }
+
+    public boolean isHigherOrEqualPriority(final Priority than) {
+        return this.priority <= than.priority;
+    }
+
+    public boolean isHigherPriority(final Priority than) {
+        return this.priority < than.priority;
+    }
+
+    public boolean isLowerOrEqualPriority(final Priority than) {
+        return this.priority >= than.priority;
+    }
+
+    public boolean isLowerPriority(final Priority than) {
+        return this.priority > than.priority;
+    }
+
+    public boolean isHigherOrEqualPriority(final int than) {
+        return this.priority <= than;
+    }
+
+    public boolean isHigherPriority(final int than) {
+        return this.priority < than;
+    }
+
+    public boolean isLowerOrEqualPriority(final int than) {
+        return this.priority >= than;
+    }
+
+    public boolean isLowerPriority(final int than) {
+        return this.priority > than;
+    }
+
+    public static boolean isHigherOrEqualPriority(final int priority, final int than) {
+        return priority <= than;
+    }
+
+    public static boolean isHigherPriority(final int priority, final int than) {
+        return priority < than;
+    }
+
+    public static boolean isLowerOrEqualPriority(final int priority, final int than) {
+        return priority >= than;
+    }
+
+    public static boolean isLowerPriority(final int priority, final int than) {
+        return priority > than;
+    }
+
+    static final Priority[] PRIORITIES = Priority.values();
+
+    /** includes special priorities */
+    public static final int TOTAL_PRIORITIES = PRIORITIES.length;
+
+    public static final int TOTAL_SCHEDULABLE_PRIORITIES = TOTAL_PRIORITIES - 1;
+
+    public static Priority getPriority(final int priority) {
+        return PRIORITIES[priority + 1];
+    }
+
+    private static int priorityCounter;
+
+    private static int nextCounter() {
+        return priorityCounter++;
+    }
+
+    public final int priority;
+
+    private Priority() {
+        this(nextCounter());
+    }
+
+    private Priority(final int priority) {
+        this.priority = priority;
+    }
+}
\ No newline at end of file