Expand thread batch util capabilities, offer more generic implementations

Author: Col-E

recaf-core/src/main/java/software/coley/recaf/util/threading/Batch.java

@@ -13,14 +13,39 @@ public interface Batch {
 	 */
 	void execute();
 
+	/**
+	 * Run the oldest added task. This will remove the task once executed.
+	 */
+	void executeOldest();
+
+	/**
+	 * Run the newest added task. This will remove the task once executed.
+	 */
+	void executeNewest();
+
 	/**
 	 * @param runnable
 	 * 		Task to execute.
 	 */
 	void add(@Nonnull Runnable runnable);
 
 	/**
-	 * Clears tasks.
+	 * Removes all tasks.
 	 */
 	void clear();
+
+	/**
+	 * Removes the oldest task.
+	 */
+	void removeOldest();
+
+	/**
+	 * Removes the newest task.
+	 */
+	void removeNewest();
+
+	/**
+	 * @return {@code true} when there are no tasks in the batch.
+	 */
+	boolean isEmpty();
 }

recaf-core/src/main/java/software/coley/recaf/util/threading/DirectBatch.java

@@ -0,0 +1,83 @@
+package software.coley.recaf.util.threading;
+
+import jakarta.annotation.Nonnull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A batch implementation that directly runs provided tasks on the calling thread.
+ *
+ * @author Matt Coley
+ */
+public class DirectBatch implements Batch {
+	private final List<Runnable> tasks = new ArrayList<>();
+
+	@Override
+	public void add(@Nonnull Runnable runnable) {
+		synchronized (tasks) {
+			tasks.add(runnable);
+		}
+	}
+
+	@Override
+	public void clear() {
+		synchronized (tasks) {
+			tasks.clear();
+		}
+	}
+
+	@Override
+	public void removeOldest() {
+		synchronized (tasks) {
+			tasks.removeFirst();
+		}
+	}
+
+	@Override
+	public void removeNewest() {
+		synchronized (tasks) {
+			tasks.removeLast();
+		}
+	}
+
+	@Override
+	public void execute() {
+		List<Runnable> tasksCopy;
+		synchronized (tasks) {
+			tasksCopy = new ArrayList<>(tasks);
+			tasks.clear();
+		}
+		for (Runnable task : tasksCopy)
+			task.run();
+	}
+
+	@Override
+	public void executeOldest() {
+		Runnable task;
+		synchronized (tasks) {
+			if (tasks.isEmpty())
+				return;
+			task = tasks.removeFirst();
+		}
+		task.run();
+	}
+
+	@Override
+	public void executeNewest() {
+		Runnable task;
+		synchronized (tasks) {
+			if (tasks.isEmpty())
+				return;
+			task = tasks.removeLast();
+		}
+		task.run();
+	}
+
+	@Override
+	public boolean isEmpty() {
+		synchronized (tasks) {
+			return tasks.isEmpty();
+		}
+	}
+}

recaf-core/src/main/java/software/coley/recaf/util/threading/ThreadUtil.java

@@ -5,7 +5,16 @@
 import org.slf4j.Logger;
 import software.coley.recaf.analytics.logging.Logging;
 
-import java.util.concurrent.*;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
@@ -362,4 +371,42 @@ public static void shutdown() {
 		logger.trace("Shutting misc executors");
 		scheduledService.shutdown();
 	}
+
+	/**
+	 * @return New task batch that executes all actions through the given executor.
+	 */
+	@Nonnull
+	public static Batch batch(@Nonnull Executor executor) {
+		return new ExecutorBatch(executor);
+	}
+
+	/**
+	 * Batch implementation that executes all tasks on a given executor.
+	 */
+	private static class ExecutorBatch extends DirectBatch {
+		private final Executor executor;
+
+		private ExecutorBatch(@Nonnull Executor executor) {
+			this.executor = executor;
+		}
+
+		@Override
+		public void execute() {
+			submit(super::execute);
+		}
+
+		@Override
+		public void executeOldest() {
+			submit(super::executeOldest);
+		}
+
+		@Override
+		public void executeNewest() {
+			submit(super::executeNewest);
+		}
+
+		private void submit(@Nonnull Runnable execution) {
+			executor.execute(execution);
+		}
+	}
 }

recaf-ui/src/main/java/software/coley/recaf/util/FxThreadUtil.java

@@ -8,6 +8,7 @@
 import javafx.beans.value.WritableValue;
 import software.coley.recaf.RecafApplication;
 import software.coley.recaf.util.threading.Batch;
+import software.coley.recaf.util.threading.DirectBatch;
 import software.coley.recaf.util.threading.ThreadPoolFactory;
 import software.coley.recaf.util.threading.ThreadUtil;
 
@@ -113,44 +114,10 @@ public static void onInitialize() {
 	}
 
 	/**
-	 * @return New execution chain.
+	 * @return New task batch that executes all actions on the FX thread.
 	 */
 	@Nonnull
 	public static Batch batch() {
-		return new FxBatch();
-	}
-
-	/**
-	 * Batch implementation that executes all tasks on the FX thread.
-	 */
-	private static class FxBatch implements Batch {
-		private final List<Runnable> tasks = new ArrayList<>();
-
-		@Override
-		public void add(@Nonnull Runnable runnable) {
-			synchronized (tasks) {
-				tasks.add(runnable);
-			}
-		}
-
-		@Override
-		public void clear() {
-			synchronized (tasks) {
-				tasks.clear();
-			}
-		}
-
-		@Override
-		public void execute() {
-			run(this::fire);
-		}
-
-		private void fire() {
-			synchronized (tasks) {
-				for (Runnable task : tasks)
-					task.run();
-				tasks.clear();
-			}
-		}
+		return ThreadUtil.batch(jfxExecutor);
 	}
 }