What is a thread pool?

ThreadPool is a group of worker threads managed as a single entity that receives tasks and distributes them among available threads. Instead of creating a new thread for each task, the pool reuses existing ones.

Main advantages:

• Reduced overhead: Creating and destroying threads is time-consuming and resource-intensive. The pool eliminates this need.
• Resource management: Limits the maximum number of concurrently executing threads, preventing system resource exhaustion.
• Performance improvement: Manages the task queue, which can increase application throughput.
• Ease of management: Provides a centralized mechanism for executing asynchronous tasks.

In Java, the java.util.concurrent package is used for thread pool management. Main interfaces and classes:

• Executor: Interface for executing tasks.
• ExecutorService: Extends Executor, providing methods for managing the pool's lifecycle and obtaining task execution results.
• Executors: Utility class for creating standard ExecutorService implementations, such as:
  • newFixedThreadPool(int nThreads): Pool with a fixed number of threads.
  • newCachedThreadPool(): Pool that creates threads as needed and reuses inactive ones.
  • newSingleThreadExecutor(): Pool with a single worker thread.
  • newScheduledThreadPool(int corePoolSize): Pool for scheduled task execution.
• ThreadPoolExecutor: Flexible implementation of ExecutorService that allows more fine-tuned pool behavior.

Example of using ExecutorService:

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

// Example task for pool execution
class MyTask implements Runnable {
    private final int taskId;

    public MyTask(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("Executing task " + taskId + " by thread " + Thread.currentThread().getName());
        try {
            Thread.sleep(100); // Simulate work
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

public class ThreadPoolExample {
    public static void main(String[] args) {
        // Create a pool with a fixed number of threads
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // Submit tasks for execution
        for (int i = 0; i < 10; i++) {
            executorService.submit(new MyTask(i));
        }

        // Properly shut down the pool after all tasks are completed
        executorService.shutdown();
    }
}

The pool's lifecycle is managed by the shutdown() and shutdownNow() methods for proper termination.