Multi-threading with thread pools

Recently, I got the opportunity to develop a concurrent system for one of the major component of our project. We wanted to divide a single high-resource demanding process into multiple concurrent processes. So, the solution was to break down the heavy process into multiple smaller tasks and process them concurrently.

In Java, concurrency can be achieved through multi-threading. The most effective way to manage a multi-threaded environment is by using a thread pool. It can be visualized as a pool of threads that can be "reused" to execute tasks, allowing each thread to execute more than one task. A thread pool is an alternative to creating a new thread for each task you need to execute.

Creating a new thread comes with performance overhead compared to reusing a thread that is already created. This is why reusing an existing thread to execute a task can result in higher total throughput than creating a new thread per task. Additionally, using a thread pool can make it easier to control how many threads are active at a time. Each thread consumes a certain amount of computer resources, such as memory, so if you have too many threads active at the same time, the total amount of resources consumed may cause the system to slow down.

Java comes with built-in thread pools in the java.util.concurrent package, so you don't have to implement your own thread pool. The ExecutorService interface provides a higher-level replacement for working with threads directly. It abstracts the creation and management of threads, offering methods to execute tasks asynchronously and manage the life-cycle of thread pools. You can create a thread pool by simply using the built-in Executors.newFixedThreadPool(int size) method, specifying the number of threads.

Benefits of Using ExecutorService

1. Thread Pool Management: Efficiently reuses a pool of threads to execute tasks, reducing the overhead of thread creation and destruction.
2. Task Scheduling: Simplifies scheduling tasks to run after a delay or at fixed intervals.
3. Graceful Shutdown: Provides mechanisms to shut down the thread pool gracefully, ensuring that all submitted tasks are completed before termination.
4. Exception Handling: Offers better handling of exceptions in asynchronous tasks.

Key Methods of ExecutorService

• submit(): Submits a task for execution and returns a Future representing the pending result.
• shutdown(): Initiates an orderly shutdown, where previously submitted tasks are executed, but no new tasks are accepted.
• shutdownNow(): Attempts to stop all actively executing tasks and halts the processing of waiting tasks.
• awaitTermination(): Blocks until all tasks have completed execution after a shutdown request or the timeout occurs.

Code Implementation

This code demonstrates the use of a fixed thread pool to run multiple tasks concurrently.

1. It creates a thread pool with 4 threads using ExecutorService.
2. Ten tasks are submitted to the pool, where each simulates some work with a 1-second sleep.
3. The thread pool is shut down gracefully after task submission, ensuring all tasks finish execution.
4. If tasks take too long, a forced shutdown is attempted.