Thread Pooling

In concurrent programming, thread pooling is a technique used to manage a group of reusable threads that can be shared among multiple tasks. By using a thread pool, we can improve performance and reduce the overhead of creating and destroying threads for each task.

Why do we need thread pooling?

Creating a new thread for each task can be expensive due to the overhead of thread creation and destruction. Additionally, creating a large number of threads can lead to resource exhaustion and poor performance. Thread pooling addresses these issues by maintaining a pool of pre-initialized threads that are ready to execute tasks.

How does thread pooling work?

A thread pool consists of a fixed number of threads that are created when the pool is initialized. These threads continuously wait for tasks to be assigned to them. When a task arrives, it is picked up by an available thread from the pool and executed. Once the task is completed, the thread is returned back to the pool and made available for the next task.

Thread pooling can be implemented using the ExecutorService interface and the Executors class in Java. The ExecutorService provides high-level methods for submitting tasks to the thread pool and managing the execution of tasks. The Executors class provides factory methods for creating different types of thread pools.

Let's take a look at an example that demonstrates thread pooling using the ExecutorService and Executors classes:

1${code}

xxxxxxxxxx

class Main {

  public static void main(String[] args) {

    // Create a thread pool with 3 threads

    ExecutorService executor = Executors.newFixedThreadPool(3);

​

    // Submit tasks to the thread pool

    for (int i = 1; i <= 10; i++) {

      final int taskNumber = i;

      executor.submit(() -> {

        System.out.println("Task " + taskNumber + " executed on thread: " + Thread.currentThread().getName());

        try {

          Thread.sleep(1000);

        } catch (InterruptedException e) {

          e.printStackTrace();

        }

      });

    }

​

    // Shutdown the thread pool

    executor.shutdown();

  }

}