ThreadPool and FutureTask.cancel

Question

Hi,
I have a fixed size thread pool executing a queue of tasks. The queue is larger than the number of threads in the pool. I try to cancel several running tasks using FutureTask.cancel(). At this point, I would expect to see the thread pool start executing the queued tasks in all of the thread pools threads. What I actually see is that the thread pool cancels all the tasks, creates a single new thread, and then sequentially executes all queued tasks in that one thread. It never recreates threads up to maxPoolSize for the queued tasks. Is this the correct behavior? Here is some code that reproduces the behavior I have described:
import java.util.Map;
import java.util.HashMap;
import java.util.concurrent.*;
public class ThreadPoolTest {
    public static void main(String... argv) throws Exception {
        ThreadPoolTest t = new ThreadPoolTest();
        t.runTest();
    public ThreadPoolTest() throws Exception {
    Map<Integer, Future<?>> futures = new HashMap<Integer, Future<?>>();
    public void runTest() throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        synchronized(futures) {
            for(int i=0; i<30; i++) {
                futures.put(i, executorService.submit(new MyThread(i)));
        Thread.sleep(1*1000);
        System.out.println("Cancelling threads");
        for(int i=0; i<10; i++) {
            Future<?> f = futures.get(i);
        if(f!=null)
            f.cancel(true);
        while(((ThreadPoolExecutor)executorService).getActiveCount() > 0) {
            System.out.println("Active count = " + ((ThreadPoolExecutor)executorService).getActiveCount());
            Thread.sleep(1000);
        executorService.shutdown();
    private class MyThread implements Runnable {
        private int threadnum = -1;
        public MyThread(int num) {
            this.threadnum = num;
        public void run() {
            System.out.println("Hello " + threadnum + " " + Thread.currentThread());
            try {
                long i = 0;
                while(i<1000000000) i++;
            } finally {
                System.out.println("Removing " + threadnum);
                synchronized(futures) {
                    futures.remove(threadnum);
            System.out.println("Goodbye " + threadnum);
}Thanks,
Anthony

Answer 1

I replaced the tasks' loop with a sleep(20000); and lo and behold, the threads are interrupted (as expected) and, interestingly, the ActiveCount stays at 10.
Apparently, threads/slots are not eliminated if the task catches the InterrupedException and exits. If the InterruptedException is not caught by the task/runnable, is it then propagated to the executor which then decides the thread must be destroyed because it suffered an uncaught exception?
So if your task catches the InterruptedException from cancel, things work as expected. However, there is no guarantee that the task will be able to catch the exception. To mitigate this factor, you may issue a sleep(0, 1), i.e. wait for 1 nanosecond, just before your runnable exits to catch any pending InterruptedExceptions. There still is a small window where the cancel may result in a lost thread, but the window is much smaller.
Your run method looks like this now:
        public void run() {
            System.out.println("Hello " + threadnum + " " + Thread.currentThread());
            try {
                long i = 0;
                while(i<1000000000) i++;
                Thread.sleep(0, 1);
            } catch (InterruptedException ie) {
                System.out.println("Interrupted " + threadnum);
            } finally {
                System.out.println("Removing " + threadnum);
                synchronized(futures) {
                    futures.remove(threadnum);
            System.out.println("Goodbye " + threadnum);
        }