+ internal rename

Author: q3769

pom.xml

@@ -30,7 +30,7 @@
 
     <groupId>io.github.q3769</groupId>
     <artifactId>conottle</artifactId>
-    <version>11.0.1</version>
+    <version>11.0.2</version>
     <packaging>jar</packaging>
     <name>conottle</name>
     <description>A Java concurrent API to throttle the maximum concurrency to process tasks for any given client while

src/main/java/conottle/Conottle.java

@@ -48,8 +48,8 @@ public final class Conottle implements ClientTaskExecutor, AutoCloseable {
             Math.max(16, Runtime.getRuntime().availableProcessors());
     private static final Logger logger = Logger.instance();
     private final ExecutorService adminExecutorService = Executors.newSingleThreadExecutor();
-    private final ConcurrentMap<Object, TaskThrottlingExecutorService> activeThrottlingExecutors;
-    private final ObjectPool<TaskThrottlingExecutorService> throttlingExecutorPool;
+    private final ConcurrentMap<Object, PendingWorkAwareExecutor> activeThrottlingExecutors;
+    private final ObjectPool<PendingWorkAwareExecutor> throttlingExecutorPool;
 
     private Conottle(@NonNull Builder builder) {
         this.activeThrottlingExecutors = new ConcurrentHashMap<>(builder.maxTotalClientsInParallel);
@@ -60,8 +60,8 @@ private Conottle(@NonNull Builder builder) {
     }
 
     @NonNull
-    private static GenericObjectPoolConfig<TaskThrottlingExecutorService> getThrottlingExecutorPoolConfig(int poolSizeMaxTotal) {
-        GenericObjectPoolConfig<TaskThrottlingExecutorService> throttlingExecutorPoolConfig =
+    private static GenericObjectPoolConfig<PendingWorkAwareExecutor> getThrottlingExecutorPoolConfig(int poolSizeMaxTotal) {
+        GenericObjectPoolConfig<PendingWorkAwareExecutor> throttlingExecutorPoolConfig =
                 new GenericObjectPoolConfig<>();
         throttlingExecutorPoolConfig.setMaxTotal(poolSizeMaxTotal);
         return throttlingExecutorPoolConfig;
@@ -78,7 +78,7 @@ public CompletableFuture<Void> execute(@NonNull Runnable command, @NonNull Objec
     public <V> CompletableFuture<V> submit(@NonNull Callable<V> task, @NonNull Object clientId) {
         CompletableFutureHolder<V> taskCompletableFutureHolder = new CompletableFutureHolder<>();
         activeThrottlingExecutors.compute(clientId, (k, presentExecutor) -> {
-            TaskThrottlingExecutorService executor = (presentExecutor == null) ? borrowFromPool() : presentExecutor;
+            PendingWorkAwareExecutor executor = (presentExecutor == null) ? borrowFromPool() : presentExecutor;
             taskCompletableFutureHolder.setCompletableFuture(executor.submit(task));
             return executor;
         });
@@ -104,15 +104,15 @@ int countActiveExecutors() {
         return activeThrottlingExecutors.size();
     }
 
-    private TaskThrottlingExecutorService borrowFromPool() {
+    private PendingWorkAwareExecutor borrowFromPool() {
         try {
             return throttlingExecutorPool.borrowObject();
         } catch (Exception e) {
             throw new IllegalStateException("Failed to borrow executor from pool " + throttlingExecutorPool, e);
         }
     }
 
-    private void returnToPool(TaskThrottlingExecutorService throttlingExecutor) {
+    private void returnToPool(PendingWorkAwareExecutor throttlingExecutor) {
         adminExecutorService.submit(() -> {
             try {
                 throttlingExecutorPool.returnObject(throttlingExecutor);

src/main/java/conottle/TaskCountingExecutorService.java renamed to src/main/java/conottle/PendingTaskCountingThrottleExecutor.java

@@ -40,7 +40,7 @@
  */
 @NotThreadSafe
 @ToString
-final class TaskCountingExecutorService implements TaskThrottlingExecutorService {
+final class PendingTaskCountingThrottleExecutor implements PendingWorkAwareExecutor {
     /**
      * Thread pool that throttles the max concurrency of this executor
      */
@@ -51,16 +51,17 @@ final class TaskCountingExecutorService implements TaskThrottlingExecutorService
      * @param taskThreadPoolCapacity
      *         the capacity of backing thread pool facilitating the async executions of this executor.
      */
-    TaskCountingExecutorService(int taskThreadPoolCapacity) {
+    PendingTaskCountingThrottleExecutor(int taskThreadPoolCapacity) {
         this.taskThreadPool = Executors.newFixedThreadPool(taskThreadPoolCapacity);
     }
 
     /**
-     * To be called on completion of each submitted task
+     * To be called on completion of each submitted task. The pending task count after decrementing the current value by
+     * one, accounting for the completion of one task. Within the synchronized context, a zero pending task count
+     * unambiguously indicates no more in-flight task pending execution on this executor.
      *
-     * @return the pending task count after decrementing the current value by one, accounting for the completion of one
-     *         task. Within the synchronized context, a return value of zero unambiguously indicates no more in-flight
-     *         task pending execution on this executor.
+     * @return true if there is no more pending tasks after the count is decremented to account for the previously
+     *         completed task
      */
     @Override
     public boolean noPendingWorkAfterTaskComplete() {

src/main/java/conottle/TaskThrottlingExecutorService.java renamed to src/main/java/conottle/PendingWorkAwareExecutor.java

@@ -30,11 +30,11 @@
 import java.util.concurrent.CompletableFuture;
 
 /**
- * Throttles total number of tasks being concurrently executed
+ * Async task executor. Implementations can provide throttling.
  */
-interface TaskThrottlingExecutorService {
+interface PendingWorkAwareExecutor {
     /**
-     * Intended to be called after a task is completed by this service.
+     * Intended to be called after each task is completed by this service.
      *
      * @return true if this executor has no more pending tasks after the task whose completion triggered this method
      *         invocation

src/main/java/conottle/PooledExecutorFactory.java

@@ -31,36 +31,36 @@
 import org.apache.commons.pool2.impl.DefaultPooledObject;
 
 /**
- * Creates pooled {@link TaskCountingExecutorService} instances that provide throttled async client task executions.
- * Each {@code TaskCountingExecutorService} instance throttles its client task concurrency at the max capacity of the
+ * Creates pooled {@link PendingTaskCountingThrottleExecutor} instances that provide throttled async client task executions.
+ * Each {@code PendingTaskCountingThrottleExecutor} instance throttles its client task concurrency at the max capacity of the
  * executor's backing thread pool.
  */
-final class PooledExecutorFactory extends BasePooledObjectFactory<TaskThrottlingExecutorService> {
+final class PooledExecutorFactory extends BasePooledObjectFactory<PendingWorkAwareExecutor> {
 
     private final int maxExecutorConcurrency;
 
     /**
      * @param maxExecutorConcurrency
-     *         max concurrent threads of the {@link TaskCountingExecutorService} instance produced by this factory
+     *         max concurrent threads of the {@link PendingTaskCountingThrottleExecutor} instance produced by this factory
      */
     PooledExecutorFactory(int maxExecutorConcurrency) {
         this.maxExecutorConcurrency = maxExecutorConcurrency;
     }
 
     @Override
     @NonNull
-    public TaskThrottlingExecutorService create() {
-        return new TaskCountingExecutorService(maxExecutorConcurrency);
+    public PendingWorkAwareExecutor create() {
+        return new PendingTaskCountingThrottleExecutor(maxExecutorConcurrency);
     }
 
     @Override
     @NonNull
-    public PooledObject<TaskThrottlingExecutorService> wrap(TaskThrottlingExecutorService throttlingExecutor) {
+    public PooledObject<PendingWorkAwareExecutor> wrap(PendingWorkAwareExecutor throttlingExecutor) {
         return new DefaultPooledObject<>(throttlingExecutor);
     }
 
     @Override
-    public void destroyObject(PooledObject<TaskThrottlingExecutorService> pooledThrottlingExecutor,
+    public void destroyObject(PooledObject<PendingWorkAwareExecutor> pooledThrottlingExecutor,
             DestroyMode destroyMode) throws Exception {
         try {
             super.destroyObject(pooledThrottlingExecutor, destroyMode);