+ using the same executor for both work and admin tasks

Author: q3769

pom.xml

@@ -27,7 +27,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>io.github.q3769</groupId>
     <artifactId>conseq4j</artifactId>
-    <version>20231102.0.20231105</version>
+    <version>20231102.0.20240511</version>
     <packaging>jar</packaging>
     <name>conseq4j</name>
     <description>A Java concurrent API to sequence related tasks while concurring unrelated ones</description>

src/main/java/conseq4j/execute/ConseqExecutor.java

@@ -30,7 +30,15 @@
 import java.time.Duration;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.*;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.Future;
 import javax.annotation.Nonnull;
 import javax.annotation.concurrent.ThreadSafe;
 import lombok.NonNull;
@@ -48,7 +56,6 @@ public final class ConseqExecutor implements SequentialExecutor, Terminable, Aut
 
     private static final int DEFAULT_CONCURRENCY = Runtime.getRuntime().availableProcessors();
     private final Map<Object, CompletableFuture<?>> activeSequentialTasks = new ConcurrentHashMap<>();
-    private final ExecutorService adminService = Executors.newSingleThreadExecutor();
     /**
      * The worker thread pool facilitates the overall async execution, independent of the submitted tasks. Any thread
      * from the pool can be used to execute any task, regardless of sequence keys. The pool capacity decides the overall
@@ -105,7 +112,7 @@ private static ConditionFactory awaitForever() {
     }
 
     /**
-     * @param command the command to run asynchronously in proper sequence
+     * @param command     the command to run asynchronously in proper sequence
      * @param sequenceKey the key under which this task should be sequenced
      * @return future result of the command, not downcast-able from the basic {@link Future} interface.
      * @see ConseqExecutor#submit(Callable, Object)
@@ -144,7 +151,7 @@ public CompletableFuture<Void> execute(@NonNull Runnable command, @NonNull Objec
      * task/stage is never added to the task work queue on the executor map and has no effect on the overall
      * sequential-ness of the work stage executions.
      *
-     * @param task the task to be called asynchronously with proper sequence
+     * @param task        the task to be called asynchronously with proper sequence
      * @param sequenceKey the key under which this task should be sequenced
      * @return future result of the task, not downcast-able from the basic {@link Future} interface.
      */
@@ -155,12 +162,10 @@ public <T> CompletableFuture<T> submit(@NonNull Callable<T> task, @NonNull Objec
                 sequenceKey,
                 (k, presentTask) -> (presentTask == null)
                         ? CompletableFuture.supplyAsync(() -> call(task), workerExecutorService)
-                        : presentTask.handleAsync((r, e) -> call(task), workerExecutorService));
+                        : presentTask.handleAsync((r, e) -> call(task)));
         CompletableFuture<?> copy = latestTask.thenApply(result -> result);
-        latestTask.whenCompleteAsync(
-                (r, e) -> activeSequentialTasks.computeIfPresent(
-                        sequenceKey, (k, checkedTask) -> checkedTask.isDone() ? null : checkedTask),
-                adminService);
+        latestTask.whenCompleteAsync((r, e) -> activeSequentialTasks.computeIfPresent(
+                sequenceKey, (k, checkedTask) -> checkedTask.isDone() ? null : checkedTask));
         return (CompletableFuture<T>) copy;
     }
 
@@ -181,23 +186,16 @@ boolean noTaskPending() {
 
     @Override
     public void terminate() {
-        new Thread(() -> {
-                    workerExecutorService.shutdown();
-                    awaitForever().until(this::noTaskPending);
-                    adminService.shutdown();
-                })
-                .start();
+        workerExecutorService.shutdown();
     }
 
     @Override
     public boolean isTerminated() {
-        return workerExecutorService.isTerminated() && adminService.isTerminated();
+        return workerExecutorService.isTerminated();
     }
 
     @Override
     public @Nonnull List<Runnable> terminateNow() {
-        List<Runnable> neverStartedTasks = workerExecutorService.shutdownNow();
-        adminService.shutdownNow();
-        return neverStartedTasks;
+        return workerExecutorService.shutdownNow();
     }
 }