ensure managed list doesn't throw rejected execution exceptions if it does not need to

Author: lucasstarsz

src/main/java/tech/fastj/systems/collections/ManagedList.java

@@ -7,7 +7,6 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
-import java.util.UUID;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
@@ -20,12 +19,11 @@
 /**
  * A form of {@link ArrayList} whose actions are managed through a {@link ScheduledExecutorService}.
  * <p>
- * This style of list provides a reliable way to stop a list's iteration as quickly as possible -- especially in the
- * event of an infinite loop. This is achievable by having the list's iterative actions run through an internal {@link
- * ScheduledExecutorService} instance.
+ * This style of list provides a reliable way to stop a list's iteration as quickly as possible -- especially in the event of an infinite
+ * loop. This is achievable by having the list's iterative actions run through an internal {@link ScheduledExecutorService} instance.
  * <p>
- * When the list's manager is {@link #shutdown() shut down}, the manager-related methods can no longer be used. However,
- * the standard {@link List} methods can still be accessed as normal.
+ * When the list's manager is {@link #shutdown() shut down}, the manager-related methods can no longer be used. However, the standard
+ * {@link List} methods can still be accessed as normal.
  * <p>
  * <b>This form of list is not meant for quick actions -- it is <i>very slow</i>.</b> Besides that, it is fairly
  * useful. It provides:
@@ -51,7 +49,6 @@ public class ManagedList<E> implements List<E> {
 
     private final ArrayList<E> list;
     private ScheduledExecutorService listManager;
-    private final UUID uuid = UUID.randomUUID();
 
     /**
      * A constructor matching {@link ArrayList#ArrayList()}.
@@ -84,8 +81,8 @@ public ManagedList(Collection<? extends E> collection) {
     }
 
     /**
-     * {@link #shutdownNow() Shuts down} the list's manager, and creates a new one. If the manager was previously shut
-     * down, this is the recommended way to restore it.
+     * {@link #shutdownNow() Shuts down} the list's manager, and creates a new one. If the manager was previously shut down, this is the
+     * recommended way to restore it.
      */
     public List<Runnable> resetManager() {
         List<Runnable> remnants = shutdownNow();
@@ -125,47 +122,61 @@ public boolean isTerminated() {
      * Runs the given action on the list immediately.
      *
      * @param action The action to run on the list.
-     * @throws IllegalStateException if an {@link InterruptedException} or {@link ExecutionException} is received. In
-     *                               the case of {@link InterruptedException}, it will be wrapped. With {@link
-     *                               ExecutionException}, its underlying exception will be wrapped.
+     * @throws IllegalStateException if an {@link InterruptedException} or {@link ExecutionException} is received. In the case of
+     *                               {@link InterruptedException}, it will be wrapped. With {@link ExecutionException}, its underlying
+     *                               exception will be wrapped.
      * @see ExecutorService#submit(Runnable)
      */
     public void run(Consumer<ArrayList<E>> action) {
+        if (listManager.isShutdown() || listManager.isTerminated()) {
+            return;
+        }
+
         try {
-            listManager.submit(() -> {
-                action.accept(list);
-            }).get();
-        } catch (InterruptedException exception) {
-            Thread.currentThread().interrupt();
+            listManager.submit(() -> action.accept(list)).get();
+        } catch (RejectedExecutionException exception) {
+            if (listManager.isShutdown() || listManager.isTerminated()) {
+                return;
+            }
+
             throw new IllegalStateException(exception);
         } catch (ExecutionException exception) {
             throw new IllegalStateException(exception.getCause());
+        } catch (InterruptedException exception) {
+            throw new IllegalStateException(exception);
         }
     }
 
     /**
      * Iterates over the given list immediately, where the given action is applied to each element of the list.
      *
      * @param action The action to run on the list's elements.
-     * @throws IllegalStateException if an {@link InterruptedException} or {@link ExecutionException} is received. In
-     *                               the case of {@link InterruptedException}, it will be wrapped. With {@link
-     *                               ExecutionException}, its underlying exception will be wrapped.
+     * @throws IllegalStateException if an {@link InterruptedException} or {@link ExecutionException} is received. In the case of
+     *                               {@link InterruptedException}, it will be wrapped. With {@link ExecutionException}, its underlying
+     *                               exception will be wrapped.
      * @see ExecutorService#submit(Runnable)
      */
     public void iterate(Consumer<E> action) {
+        if (listManager.isShutdown() || listManager.isTerminated()) {
+            return;
+        }
+
         try {
-            listManager.submit(
-                    () -> {
-                        for (E element : list) {
-                            action.accept(element);
-                        }
-                    }
-            ).get();
-        } catch (InterruptedException exception) {
-            Thread.currentThread().interrupt();
+            listManager.submit(() -> {
+                for (E element : list) {
+                    action.accept(element);
+                }
+            }).get();
+        } catch (RejectedExecutionException exception) {
+            if (listManager.isShutdown() || listManager.isTerminated()) {
+                return;
+            }
+
             throw new IllegalStateException(exception);
         } catch (ExecutionException exception) {
             throw new IllegalStateException(exception.getCause());
+        } catch (InterruptedException exception) {
+            throw new IllegalStateException(exception);
         }
     }
 
@@ -175,15 +186,23 @@ public void iterate(Consumer<E> action) {
      * @param action The action to run on the list.
      * @param delay  The time from now to the task's delayed execution.
      * @param unit   The time unit of the {@code delay} parameter.
-     * @return a {@link ScheduledFuture} representing pending completion of the task and whose {@link
-     * ScheduledFuture#get()} method will return {@code null} upon completion.
+     * @return a {@link ScheduledFuture} representing pending completion of the task and whose {@link ScheduledFuture#get()} method will
+     * return {@code null} upon completion.
      * @throws RejectedExecutionException if the task cannot be scheduled for execution
      * @throws NullPointerException       if command or unit is null
      */
     public ScheduledFuture<?> schedule(Consumer<ArrayList<E>> action, long delay, TimeUnit unit) {
-        return listManager.schedule(() -> {
-            action.accept(list);
-        }, delay, unit);
+        ScheduledFuture<?> scheduledFuture = null;
+
+        try {
+            return listManager.schedule(() -> action.accept(list), delay, unit);
+        } catch (RejectedExecutionException exception) {
+            if (!listManager.isShutdown() && !listManager.isTerminated()) {
+                throw new IllegalStateException(exception.getCause());
+            }
+        }
+
+        return scheduledFuture;
     }
 
     /**
@@ -192,22 +211,32 @@ public ScheduledFuture<?> schedule(Consumer<ArrayList<E>> action, long delay, Ti
      * @param action The action to run on the list's elements.
      * @param delay  The time from now to the task's delayed execution.
      * @param unit   The time unit of the {@code delay} parameter.
-     * @return a {@link ScheduledFuture} representing pending completion of the task and whose {@link
-     * ScheduledFuture#get()} method will return {@code null} upon completion.
+     * @return a {@link ScheduledFuture} representing pending completion of the task and whose {@link ScheduledFuture#get()} method will
+     * return {@code null} upon completion.
      * @throws RejectedExecutionException if the task cannot be scheduled for execution
      * @throws NullPointerException       if command or unit is null
      * @see ScheduledExecutorService#schedule(Runnable, long, TimeUnit)
      */
     public ScheduledFuture<?> scheduleIterate(Consumer<E> action, long delay, TimeUnit unit) {
-        return listManager.schedule(
+        ScheduledFuture<?> scheduledFuture = null;
+
+        try {
+            return listManager.schedule(
                 () -> {
                     for (E element : list) {
                         action.accept(element);
                     }
                 },
                 delay,
                 unit
-        );
+            );
+        } catch (RejectedExecutionException exception) {
+            if (!listManager.isShutdown() && !listManager.isTerminated()) {
+                throw new IllegalStateException(exception.getCause());
+            }
+        }
+
+        return scheduledFuture;
     }
 
     /**
@@ -217,18 +246,25 @@ public ScheduledFuture<?> scheduleIterate(Consumer<E> action, long delay, TimeUn
      * @param initialDelay The time to delay first execution
      * @param period       The period between successive executions
      * @param unit         The time unit of the initialDelay and period parameters
-     * @return A {@link ScheduledFuture} representing pending completion of the series of repeated tasks.  The future's
-     * {@link Future#get()} method will never return normally, and will throw an exception upon task cancellation or
-     * abnormal termination of a task execution.
+     * @return A {@link ScheduledFuture} representing pending completion of the series of repeated tasks.  The future's {@link Future#get()}
+     * method will never return normally, and will throw an exception upon task cancellation or abnormal termination of a task execution.
      * @throws RejectedExecutionException if the task cannot be scheduled for execution
      * @throws NullPointerException       if command or unit is null
      * @throws IllegalArgumentException   if period less than or equal to zero
      * @see ScheduledExecutorService#scheduleAtFixedRate(Runnable, long, long, TimeUnit)
      */
     public ScheduledFuture<?> scheduleAtFixedRate(Consumer<ArrayList<E>> action, long initialDelay, long period, TimeUnit unit) {
-        return listManager.scheduleAtFixedRate(() -> {
-            action.accept(list);
-        }, initialDelay, period, unit);
+        ScheduledFuture<?> scheduledFuture = null;
+
+        try {
+            return listManager.scheduleAtFixedRate(() -> action.accept(list), initialDelay, period, unit);
+        } catch (RejectedExecutionException exception) {
+            if (!listManager.isShutdown() && !listManager.isTerminated()) {
+                throw new IllegalStateException(exception.getCause());
+            }
+        }
+
+        return scheduledFuture;
     }
 
     /**
@@ -238,25 +274,33 @@ public ScheduledFuture<?> scheduleAtFixedRate(Consumer<ArrayList<E>> action, lon
      * @param initialDelay The time to delay first execution.
      * @param period       The period between successive executions.
      * @param unit         The time unit of the initialDelay and period parameters.
-     * @return A {@link ScheduledFuture} representing pending completion of the series of repeated tasks.  The future's
-     * {@link Future#get()} method will never return normally, and will throw an exception upon task cancellation or
-     * abnormal termination of a task execution.
+     * @return A {@link ScheduledFuture} representing pending completion of the series of repeated tasks.  The future's {@link Future#get()}
+     * method will never return normally, and will throw an exception upon task cancellation or abnormal termination of a task execution.
      * @throws RejectedExecutionException if the task cannot be scheduled for execution.
      * @throws NullPointerException       if command or unit is null.
      * @throws IllegalArgumentException   if period less than or equal to zero.
      * @see ScheduledExecutorService#scheduleAtFixedRate(Runnable, long, long, TimeUnit)
      */
     public ScheduledFuture<?> scheduledIterateAtFixedRate(Consumer<E> action, long initialDelay, long period, TimeUnit unit) {
-        return listManager.scheduleAtFixedRate(
-                () -> {
+        ScheduledFuture<?> scheduledFuture = null;
+
+        try {
+            scheduledFuture = listManager.scheduleAtFixedRate(() -> {
                     for (E element : list) {
                         action.accept(element);
                     }
                 },
                 initialDelay,
                 period,
                 unit
-        );
+            );
+        } catch (RejectedExecutionException exception) {
+            if (!listManager.isShutdown() && !listManager.isTerminated()) {
+                throw new IllegalStateException(exception.getCause());
+            }
+        }
+
+        return scheduledFuture;
     }
 
     /**
@@ -266,18 +310,25 @@ public ScheduledFuture<?> scheduledIterateAtFixedRate(Consumer<E> action, long i
      * @param initialDelay The time to delay first execution.
      * @param delay        The delay between the termination of one execution and the commencement of the next.
      * @param unit         The time unit of the initialDelay and delay parameters.
-     * @return a {@link ScheduledFuture} representing pending completion of the series of repeated tasks.  The future's
-     * {@link Future#get()} method will never return normally, and will throw an exception upon task cancellation or
-     * abnormal termination of a task execution.
+     * @return a {@link ScheduledFuture} representing pending completion of the series of repeated tasks.  The future's {@link Future#get()}
+     * method will never return normally, and will throw an exception upon task cancellation or abnormal termination of a task execution.
      * @throws RejectedExecutionException if the task cannot be scheduled for execution.
      * @throws NullPointerException       if command or unit is null.
      * @throws IllegalArgumentException   if delay less than or equal to zero.
      * @see ScheduledExecutorService#scheduleWithFixedDelay(Runnable, long, long, TimeUnit)
      */
     public ScheduledFuture<?> scheduleWithFixedDelay(Consumer<ArrayList<E>> action, long initialDelay, long delay, TimeUnit unit) {
-        return listManager.scheduleWithFixedDelay(() -> {
-            action.accept(list);
-        }, initialDelay, delay, unit);
+        ScheduledFuture<?> scheduledFuture = null;
+
+        try {
+            scheduledFuture = listManager.scheduleWithFixedDelay(() -> action.accept(list), initialDelay, delay, unit);
+        } catch (RejectedExecutionException exception) {
+            if (!listManager.isShutdown() && !listManager.isTerminated()) {
+                throw new IllegalStateException(exception.getCause());
+            }
+        }
+
+        return scheduledFuture;
     }
 
 
@@ -288,16 +339,18 @@ public ScheduledFuture<?> scheduleWithFixedDelay(Consumer<ArrayList<E>> action,
      * @param initialDelay The time to delay first execution.
      * @param delay        The delay between the termination of one execution and the commencement of the next.
      * @param unit         The time unit of the initialDelay and delay parameters.
-     * @return a {@link ScheduledFuture} representing pending completion of the series of repeated tasks.  The future's
-     * {@link Future#get()} method will never return normally, and will throw an exception upon task cancellation or
-     * abnormal termination of a task execution.
+     * @return a {@link ScheduledFuture} representing pending completion of the series of repeated tasks.  The future's {@link Future#get()}
+     * method will never return normally, and will throw an exception upon task cancellation or abnormal termination of a task execution.
      * @throws RejectedExecutionException if the task cannot be scheduled for execution.
      * @throws NullPointerException       if command or unit is null.
      * @throws IllegalArgumentException   if delay less than or equal to zero.
      * @see ScheduledExecutorService#scheduleWithFixedDelay(Runnable, long, long, TimeUnit)
      */
     public ScheduledFuture<?> scheduledIterateWithFixedDelay(Consumer<E> action, long initialDelay, long delay, TimeUnit unit) {
-        return listManager.scheduleWithFixedDelay(
+        ScheduledFuture<?> scheduledFuture = null;
+
+        try {
+            scheduledFuture = listManager.scheduleWithFixedDelay(
                 () -> {
                     for (E element : list) {
                         action.accept(element);
@@ -306,7 +359,14 @@ public ScheduledFuture<?> scheduledIterateWithFixedDelay(Consumer<E> action, lon
                 initialDelay,
                 delay,
                 unit
-        );
+            );
+        } catch (RejectedExecutionException exception) {
+            if (!listManager.isShutdown() && !listManager.isTerminated()) {
+                throw new IllegalStateException(exception.getCause());
+            }
+        }
+
+        return scheduledFuture;
     }
 
     @Override