ThreadPoolExecutor#getPoolSize() vs ThreadPoolExecutor#getActiveCount() what is the difference

I've been playing with ThreadPoolExecutor. I needed a method that returns the number of threads which are currently running. So I decided to use ThreadPoolExecutor#getActiveCount.

However, when I was testing my methods I noticed something interesting: ThreadPoolExecutor#getActiveCount is always equal to ThreadPoolExecutor#getPoolSize.

Here is a sample code to reproduce it:

class ExecutorTest {

        private ThreadPoolExecutor executor;

        ExecutorTest() {
            executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        }

        @Test
        void test() {
            executor.execute(makeRunnable(100, "1"));
            printExecutorState();
            executor.execute(makeRunnable(100, "2"));
            printExecutorState();
            executor.execute(makeRunnable(100, "3"));
            printExecutorState();
            executor.execute(makeRunnable(100, "4"));
            printExecutorState();

            System.out.println("==Changing thread core&max pool size==");
            executor.setCorePoolSize(2);
            executor.setMaximumPoolSize(2);

            printExecutorState();
            assertThat(executor.getMaximumPoolSize()).isEqualTo(2);
            assertThat(executor.getActiveCount()).isEqualTo(4);
        }

        private Runnable makeRunnable(long workTime, String name) {
            return () -> {
                long startTime = System.currentTimeMillis();
                System.out.println("Running " + name);
                while (System.currentTimeMillis() - startTime < workTime) {
                }
                System.out.println("Exited " + name);
            };
        }

        private void printExecutorState() {
            int poolSize = executor.getPoolSize();
            int corePoolSize = executor.getCorePoolSize();
            int maxPoolSize = executor.getMaximumPoolSize();
            int running = executor.getActiveCount();

            String currentState = String.format(
                    "poolSize=%d, corePoolSize=%d, maxPoolSize=%d, running=%d",
                    poolSize,
                    corePoolSize,
                    maxPoolSize,
                    running
            );

            System.out.println(currentState);
        }
    }

It prints the following:

Running 1
poolSize=1, corePoolSize=10, maxPoolSize=10, running=1
Running 2
poolSize=2, corePoolSize=10, maxPoolSize=10, running=2
Running 3
poolSize=3, corePoolSize=10, maxPoolSize=10, running=3
Running 4
poolSize=4, corePoolSize=10, maxPoolSize=10, running=4
==Changing thread core&max pool size==
poolSize=4, corePoolSize=2, maxPoolSize=2, running=4

Now the question is what is the difference between these methods? Does it make sense to use ThreadPoolExecutor#getPoolSize to retrieve number of running threads?

You can get the difference if you simply look at javadoc for the functions:

/**
* Returns the current number of threads in the pool.
*
* @return the number of threads
*/
public int getPoolSize() 

/**
* Returns the approximate number of threads that are actively
* executing tasks.
*
* @return the number of threads
*/
public int getActiveCount()

A thread that is in the pool and not executing any task will be included getPoolSize() but not in getActiveCount(). In your initial code, you created thread pool with pool size 10, but submitted 4 tasks. Hence pool size was 10 and active count was 4. So use of ThreadPoolExecutor#getPoolSize to retrieve number of running threads is wrong. It just gives you the number of threads created, the number of actively running threads is given by active count.

In your use case, notice how the pool size is still 4 even after reducing max pool size to 2. So what is happening is 4 threads are executing 4 tasks.

First two threads that complete their task will terminate. At that point, pool size will be reduced to 2 and active will still be 2 (other tasks in progress).

When other two threads complete their task, pool size will remain 2 (core pool size) but active will revert to 0 since no tasks are running.