How to use a thread pool in Java?

Using thread pools can improve performance and reduce overhead. The answer is to efficiently handle multitasking by reusing threads; 1. Select the appropriate thread pool type, such as newFixedThreadPool, newCachedThreadPool, newSingleThreadExecutor or newScheduledThreadPool. It is recommended to use ThreadPoolExecutor directly in the production environment for better control; 2. When submitting tasks, you can use Runnable (no return value) or Callable (there is a return result and obtained through Future); 3. The thread pool must be closed correctly. First call shutdown(), then combine awaitTermination() to wait for the task to complete, and if necessary, call shutdownNow() to force termination to avoid the JVM being unable to exit; finally, follow best practices, set the pool size reasonably, handle exceptions, and ensure resource cleaning.

Using a thread pool in Java helps manage multiple threads efficiently, especially in applications that handle many short-lived tasks. Instead of creating a new thread for each task, you reuse a pool of existing threads, which reduces overhead and improves performance.

Java provides the java.util.concurrent package, which includes the ExecutorService interface and Executors factory class to make working with thread pools easy.

Here's how to use a thread pool in Java:

1. Choose the Right Type of Thread Pool

Use Executors to create different types of thread pools based on your needs:

• Fixed thread pool : Reuses a fixed number of threads.

  

   ExecutorService executor = Executors.newFixedThreadPool(4);

• Cached thread pool : Creates new threads as needed, but reuses previously constructed threads when available.

   ExecutorService executor = Executors.newCachedThreadPool();

• Single thread executor : Uses a single worker thread.

   ExecutorService executor = Executors.newSingleThreadExecutor();

• Scheduled thread pool : For scheduled tasks to run after a delay or periodically.

   ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);

⚠️ Note: In production, especially with large-scale applications, prefer creating thread pools directly with ThreadPoolExecutor for better control and visibility.

2. Submit Tasks to the Thread Pool

You can submit tasks in two ways:

a) Using Runnable (no return value)

 executor.submit(() -> {
    System.out.println("Task executed by " Thread.currentThread().getName());
});

b) Using Callable (returns a result)

 Future<Integer> future = executor.submit(() -> {
    return 42; // some computing
});

// Later, get the result (this blocks until the task completes)
try {
    Integer result = future.get(); // returns 42
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

3. Shut Down the Thread Pool Properly

Always shut down the executor to allow the JVM to exit cleanly.

 // Allow previously submitted tasks to finish, but don't accept new ones
executor.shutdown();

// Optional: wait for tasks to complete with a timeout
try {
    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
        executor.shutdownNow(); // force shutdown if tasks don't finish
    }
} catch (InterruptedException e) {
    executor.shutdownNow();
    Thread.currentThread().interrupt();
}

? Never forget to shut down your thread pool — otherwise, the JVM may not terminate.

Example: Complete Usage

 import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 5; i ) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " taskId " running on " Thread.currentThread().getName());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("Task " taskId " completed");
            });
        }

        executor.shutdown();
        try {
            if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }

        System.out.println("All tasks submitted and completed.");
    }
}

Best Practices

• Avoid Executors.newCachedThreadPool() in unbounded workloads — it can create too many threads.
• Use ThreadPoolExecutor directly when you need fine control over queue size, rejection policies, or thread naming.
• Handle exceptions in tasks — uncaught exceptions in Runnable can silently fail.
• Use try-finally or try-with-resources (if using AutoCloseable wrappers) to ensure shutdown.

Basically, just pick the right pool size, submit your tasks, and always clean up. It's simple but powerful.

The above is the detailed content of How to use a thread pool in Java?. For more information, please follow other related articles on the PHP Chinese website!