Mastering Java Thread Pools: When to Use Each Executor Type

What is a Thread Pool?

A thread pool pre‑creates a set of worker threads and reuses them for incoming tasks, avoiding the overhead of repeatedly creating and destroying threads.

Advantages

Reduced resource consumption : Reusing threads eliminates creation/destruction costs.

Faster response : Tasks can start immediately without waiting for a new thread.

Improved manageability : Centralized control prevents uncontrolled thread growth and improves stability.

Extended functionality : Executors such as ScheduledThreadPoolExecutor support delayed or periodic execution.

Creation Methods

Thread pools can be created via the Executors factory class or by directly constructing a ThreadPoolExecutor. The following seven variants are commonly used.

1. FixedThreadPool

Creates a pool with a fixed number of threads; excess tasks wait in an unbounded queue.

public static void fixedThreadPool() {
    ExecutorService pool = Executors.newFixedThreadPool(2);
    Runnable task = () -> System.out.println("Task executed, thread: " + Thread.currentThread().getName());
    // submit four tasks
    pool.submit(task);
    pool.execute(task);
    pool.execute(task);
    pool.execute(task);
}

2. CachedThreadPool

Creates threads as needed and reuses idle ones after a timeout.

public static void cachedThreadPool() {
    ExecutorService pool = Executors.newCachedThreadPool();
    for (int i = 0; i < 10; i++) {
        pool.execute(() -> {
            System.out.println("Task executed, thread: " + Thread.currentThread().getName());
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException ignored) {}
        });
    }
}

3. SingleThreadExecutor

Creates a single worker thread that processes tasks sequentially (FIFO).

public static void singleThreadExecutor() {
    ExecutorService pool = Executors.newSingleThreadExecutor();
    for (int i = 0; i < 10; i++) {
        final int index = i;
        pool.execute(() -> {
            System.out.println(index + ": task executed");
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException ignored) {}
        });
    }
}

4. ScheduledThreadPool

Executes tasks after a delay or periodically.

public static void scheduledThreadPool() {
    ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
    System.out.println("Task added at: " + new Date());
    pool.schedule(() -> {
        System.out.println("Task executed at: " + new Date());
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException ignored) {}
    }, 1, TimeUnit.SECONDS);
}

5. SingleThreadScheduledExecutor

Single‑thread version of a scheduled pool.

public static void singleThreadScheduledExecutor() {
    ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
    System.out.println("Task added at: " + new Date());
    pool.schedule(() -> {
        System.out.println("Task executed at: " + new Date());
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException ignored) {}
    }, 2, TimeUnit.SECONDS);
}

6. WorkStealingPool (JDK 8+)

Creates a work‑stealing pool where tasks are distributed among available threads; execution order is nondeterministic.

public static void workStealingPool() {
    ExecutorService pool = Executors.newWorkStealingPool();
    for (int i = 0; i < 10; i++) {
        final int index = i;
        pool.execute(() -> System.out.println(index + " executed by " + Thread.currentThread().getName()));
    }
    while (!pool.isTerminated()) {}
}

7. Direct ThreadPoolExecutor Construction

Provides full control via seven configurable parameters.

public static void customThreadPool() {
    ThreadPoolExecutor pool = new ThreadPoolExecutor(
        5,               // corePoolSize
        10,              // maximumPoolSize
        100, TimeUnit.SECONDS,
        new LinkedBlockingQueue<>(10) // workQueue capacity
    );
    for (int i = 0; i < 10; i++) {
        final int index = i;
        pool.execute(() -> {
            System.out.println(index + " executed by " + Thread.currentThread().getName());
            try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
        });
    }
}

ThreadPoolExecutor Parameters

corePoolSize : Minimum number of threads kept alive.

maximumPoolSize : Upper bound of thread count when the queue is full.

keepAliveTime : Time that excess threads may stay idle before termination.

unit : Time unit for keepAliveTime (e.g., TimeUnit.SECONDS).

workQueue : Blocking queue for pending tasks (e.g., LinkedBlockingQueue, SynchronousQueue).

threadFactory : Factory that creates new threads (default: non‑daemon, normal priority).

handler : Rejection policy when the pool cannot accept new tasks.

Execution Flow

If the current thread count is less than corePoolSize, a new thread is created.

If the count is at least corePoolSize and the queue is not full, the task is enqueued.

If the queue is full and the count is below maximumPoolSize, a new thread is created; otherwise the task is rejected.

Rejection Policies

AbortPolicy

: Throws RejectedExecutionException. CallerRunsPolicy: Executes the task in the calling thread. DiscardOldestPolicy: Drops the oldest queued task and retries. DiscardPolicy: Silently discards the new task.

Example using DiscardPolicy:

public static void demoDiscardPolicy() {
    Runnable r = () -> {
        System.out.println("Task executed at " + new Date() + " by " + Thread.currentThread().getName());
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException ignored) {}
    };
    ThreadPoolExecutor pool = new ThreadPoolExecutor(
        1, 1, 100, TimeUnit.SECONDS,
        new LinkedBlockingQueue<>(1),
        new ThreadPoolExecutor.DiscardPolicy()
    );
    pool.execute(r);
    pool.execute(r);
    pool.execute(r);
    pool.execute(r);
}

Custom rejection handler example:

public static void demoCustomHandler() {
    Runnable r = () -> {
        System.out.println("Task executed at " + new Date() + " by " + Thread.currentThread().getName());
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException ignored) {}
    };
    ThreadPoolExecutor pool = new ThreadPoolExecutor(
        1, 1, 100, TimeUnit.SECONDS,
        new LinkedBlockingQueue<>(1),
        new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable task, ThreadPoolExecutor executor) {
                System.out.println("Custom rejection handling");
            }
        }
    );
    pool.execute(r);
    pool.execute(r);
    pool.execute(r);
    pool.execute(r);
}

Choosing a Thread Pool

Alibaba’s Java Development Manual recommends constructing a ThreadPoolExecutor directly instead of using the Executors factory. The factory methods can hide dangerous defaults (e.g., unbounded queues in newFixedThreadPool or unlimited thread creation in newCachedThreadPool) that may lead to OOM.

Therefore, create a ThreadPoolExecutor with explicit parameters that match the workload and resource limits.

References

https://tech.meituan.com/2020/04/02/java-pooling-pratice-in-meituan.html

https://www.cnblogs.com/pcheng/p/13540619.html