Various changes to JobState/WorkerPool to make them more scrutable.

Fixed shutting down threads to no longer spew InterruptedException related
logs.

Author: pspeed42

release-notes.md

@@ -11,7 +11,15 @@ Version 1.8.0 (unreleased)
     of an existing/custom GameSystemManager.
 * Added GameSystemsState.getGameSystemManager() and 
     GameSystemsState.get(class, boolean) methods.
-* Added RecurringTaskSystem for executing general tasks once per frame.    
+* Added RecurringTaskSystem for executing general tasks once per frame.
+* Added JobState/WorkerPool.isBusy() to indicate if there are still pending/running
+    workers.
+* Added JobState.getPoolSize() for querying the number of threads in the pool.
+* Modified JobState.getQueuedCount()/getActiveCount() to return the live numbers
+    from WorkerPool instead of the (likely delayed) numbers that the versioned
+    objects are tracking.
+* Fixed an issue where shutdown workers were spewing InterruptedException stack
+    traces to the logs during shutdown.
 
 
 Version 1.7.0 (latest)

src/main/java/com/simsilica/thread/JobState.java

@@ -141,11 +141,29 @@ public boolean isQueued( Job job ) {
         return workers.isQueued(job);
     }
 
+    /**
+     *  Returns the pool size that was set for the worker pool.
+     */
+    public int getPoolSize() {
+        return workers.getPoolSize();
+    }
+
+    /**
+     *  Returns true if the worker pool has any pending work to do
+     *  or is in the middle of doing that work.
+     */
+    public boolean isBusy() {
+        return workers.isBusy();
+    }
+
     /**
      *  Returns the current count of jobs waiting to be run.
      */
     public int getQueuedCount() {
-        return queuedCount.getObject();
+        //return queuedCount.getObject();
+        // The holder could be as much as a full frame delayed
+        // so we'll query the workers directly.
+        return workers.getQueuedJobCount();
     }
 
     /**
@@ -161,7 +179,10 @@ public VersionedReference<Integer> createQueuedCountReference() {
      *  a thread or waiting to be 'finished'.
      */
     public int getActiveCount() {
-        return activeCount.getObject();
+        //return activeCount.getObject();
+        // The holder could be as much as a full frame delayed
+        // so we'll query the workers directly.
+        return workers.getActiveJobCount();
     }
 
     /**

src/main/java/com/simsilica/thread/WorkerPool.java

@@ -42,6 +42,8 @@
 
 import org.slf4j.*;
 
+import com.google.common.base.Throwables;
+
 /**
  *  Manages a thread pool that can be used to run Job objects that
  *  have a two phase execution: 1) run on a background thread, 2)
@@ -81,6 +83,8 @@ public class WorkerPool {
     private AtomicInteger activeCount = new AtomicInteger(0);
 
     private AtomicLong errorCount = new AtomicLong(0);
+    
+    private boolean shuttingDown = false;
 
     /**
      *  Creates a worker pool with 4 worker threads.
@@ -208,6 +212,14 @@ public int getActiveJobCount() {
         return activeCount.get();
     }
 
+    /**
+     *  Returns true if the worker pool has any pending work to do
+     *  or is in the middle of doing that work.
+     */
+    public boolean isBusy() {
+        return (getActiveJobCount() + getQueuedJobCount()) > 0;
+    }
+
     /**
      *  Performs an immediate shutdown where all active threads are
      *  interrupted and any jobs queued are not executed.  Jobs waiting
@@ -216,6 +228,7 @@ public int getActiveJobCount() {
      *  have completed.
      */
     public void shutdownNow( boolean awaitTermination ) {
+        shuttingDown = true;
         workers.shutdownNow();
         if( awaitTermination ) {
             log.info("Waiting for thread pool shutdown");
@@ -313,9 +326,13 @@ public void run() {
             try {
                 job.runOnWorker();
             } catch( Exception e ) {
-                log.error("Error running job:" + job, e);
-                activeCount.decrementAndGet();
-                errorCount.incrementAndGet();
+                if( shuttingDown && Throwables.getRootCause(e) instanceof InterruptedException ) {
+                    log.info("Thread interrupted successfully");
+                } else {
+                    log.error("Error running job:" + job, e);
+                    activeCount.decrementAndGet();
+                    errorCount.incrementAndGet();
+                }
                 return;
             }
             if( log.isTraceEnabled() ) {