Integrating CompletableFuture with Custom Thread Pools

Welcome back! In the previous lessons, we learned about custom thread pools and CompletableFuture, two powerful tools for managing concurrent and asynchronous tasks. In this lesson, let's combine them together and explore how integrating CompletableFuture with custom thread pools can optimize task execution and resource management.

What You'll Learn

In this lesson, we'll focus on: How to execute CompletableFuture tasks using custom executors. The importance of choosing the right thread pool size for different types of tasks. How CompletableFuture enhances parallel task execution with custom thread pools. By the end of this lesson, you’ll have a practical understanding of how to effectively manage asynchronous tasks while controlling the thread pool's size and behavior.

Recap: CompletableFuture, Executors, and Their Combination

We’ve already explored CompletableFuture, which allows you to run tasks asynchronously without blocking the main thread. Additionally, we’ve worked with executors, which let us manage thread pools and control how tasks are executed by threads. Now, by combining custom thread pools with CompletableFuture, you can better manage thread allocation, task execution, and overall performance. This integration allows for: Custom control over how many threads are used to process tasks. Flexible management of asynchronous tasks . Better resource utilization by configuring the pool to match task demands. Let’s now move into the practical implementation of this concept.

Custom Thread Factory

To better understand how threads are created in our custom executor, let’s first look at the CustomThreadFactory : Java // Custom Thread Factory public class CustomThreadFactory implements ThreadFactory {private final AtomicInteger counter = new AtomicInteger(1); @Override public Thread newThread(Runnable r) {return new Thread(r, "CustomExecutorThread-" + counter.getAndIncrement());}} // Custom Thread Factory public class CustomThreadFactory implements ThreadFactory {private final AtomicInteger counter = new AtomicInteger(1); @Override public Thread newThread(Runnable r) {return new Thread(r, "CustomExecutorThread-" + counter.getAndIncrement());}} This class generates custom-named threads, making it easier to monitor task execution and identify which threads are handling which tasks. Each thread is named sequentially using counter.getAndIncrement(), so the first thread might be called CustomExecutorThread-1, and the next one will be CustomExecutorThread-2, and so on. We use AtomicInteger for the counter variable to ensure thread-safe operations when multiple threads attempt to increment the counter at the same time.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Two Independent Tasks

In this part, we define two independent tasks using CompletableFuture.supplyAsync(). Here, we explicitly pass the customExecutor as an argument, which means these tasks will be executed by the custom thread pool we just created.

Java

// Two independent tasks
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("Task 1 executed by " + Thread.currentThread().getName());
    sleep(1000);
    return "Data from Task 1";
}, customExecutor);

CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("Task 2 executed by " + Thread.currentThread().getName());
    sleep(1500);
    return 100;
}, customExecutor);

// Two independent tasks
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("Task 1 executed by " + Thread.currentThread().getName());
    sleep(1000);
    return "Data from Task 1";
}, customExecutor);

CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("Task 2 executed by " + Thread.currentThread().getName());
    sleep(1500);
    return 100;
}, customExecutor);

Here's what we're doing in the above code:

Passing the customExecutor: By passing the customExecutor as the second argument to supplyAsync(), we are explicitly telling CompletableFuture to run these tasks on threads from our custom thread pool, rather than using the default pool. This allows us to control the number of threads and monitor which threads handle each task.
Task Distribution: The tasks will be distributed among the 3 available threads in the pool. For example, Task 1 might run on CustomExecutorThread-1, while Task 2 might run on CustomExecutorThread-2. This provides visibility into how tasks are handled by specific threads.

This integration of custom thread pools with CompletableFuture is particularly useful when you need to control how resources are allocated for concurrent tasks, preventing resource exhaustion while improving overall performance.