Executor Framework in Java

The Executor framework, in the java.util.concurrent package, is used to run tasks on a pool of reusable threads instead of creating a new Thread for every task. You hand a task (a Runnable or Callable) to an executor, and it decides which thread runs it and when. A thread pool keeps a set of worker threads alive and gives each new task to a free worker, which saves the cost of creating threads and limits how many run at once. In this lesson, you will learn the main interfaces and how to submit tasks.

Why Use a Thread Pool?

The Main Types

Methods of ExecutorService

Example: Six Tasks on Three Threads

Let's see an example that runs six tasks on a pool of three worker threads.

import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class PoolDemo {
    public static void main(String[] args) {
        Set<String> workers = ConcurrentHashMap.newKeySet();
        long start = System.nanoTime();
 
        try (ExecutorService pool = Executors.newFixedThreadPool(3)) {
            for (int i = 1; i <= 6; i++) {
                int task = i;
                pool.submit(() -> {
                    workers.add(Thread.currentThread().getName());
                    sleep(200);
                    return task;
                });
            }
        }
 
        long ms = (System.nanoTime() - start) / 1_000_000;
        System.out.println("Different worker threads used: " + workers.size());
        System.out.println("Took about two rounds (400-600 ms)? "
            + (ms >= 400 && ms < 600));
    }
 
    static void sleep(long ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

Different worker threads used: 3
Took about two rounds (400-600 ms)? true

Explanation: Executors.newFixedThreadPool(3) creates a pool with three worker threads. Six tasks are submitted; three run at once and the other three wait in the queue, so the work takes two rounds of 200 milliseconds. Only three threads were ever created, and each was reused. Since Java 19, ExecutorService is AutoCloseable, so try-with-resources shuts the pool down and waits for the tasks to finish.

Sizing a Pool

Common Mistakes

Forgetting to shut down the executor. Its non-daemon threads keep the program alive.

Creating a new executor for every task. Create one and reuse it.

Ignoring the Future from submit. An exception thrown by the task is hidden inside it until you call get().

Interview Corner

Practice

1. Easy: Submit five tasks that each print their task number and thread name to a pool of two threads.
2. Harder: Use invokeAll to compute the squares of the numbers 1 to 10 in a pool of four threads, and print the sum of the results.

Key Takeaways