Modern approach to parallelism in Java - Fork/Join Framework, CompletableFuture, and virtual threads (Project Loom)

Modern applications require high scalability and responsiveness. With the increase in the number of processor cores, the task of effective parallelism has become one of the key challenges. Java provides several tools for organizing parallel and asynchronous execution of tasks — from Fork/Join Framework and CompletableFuture to virtual threads from Project Loom. Let's break them down in detail to understand where each is most effective.

1️⃣ Fork/Join Framework

Fork/Join Framework, introduced in Java 7, is a specialized thread pool for tasks of the "divide and conquer" (divide and conquer) type. A large task is divided into smaller subtasks that are executed in parallel, and then merged into a common result.

Key elements:

• ForkJoinPool — a thread pool optimized for recursive and small tasks.
• RecursiveTask<V> and RecursiveAction — classes for tasks with a return result and without it.
• Work-Stealing — a balancing mechanism where threads steal tasks from other threads, to avoid idleness and ensure maximum CPU utilization.

Example:

class FibonacciTask extends RecursiveTask<Integer> {
    final int n;

    FibonacciTask(int n) { this.n = n; }

    @Override
    protected Integer compute() {
        if (n <= 1) return n;
        FibonacciTask f1 = new FibonacciTask(n - 1);
        f1.fork();
        FibonacciTask f2 = new FibonacciTask(n - 2);
        return f2.compute() + f1.join();
    }
}
  

Fork/Join is ideally suited for CPU-bound tasks — computations that can be broken down into independent blocks. However, excessive recursion can lead to overhead, and blocking operations reduce the pool's efficiency.

2️⃣ CompletableFuture — asynchronous programming with functional style

With the arrival of Java 8, the language introduced CompletableFuture — a powerful tool for asynchronous programming. It allows you to create chains of dependent operations, handle errors, and perform tasks non-blockingly, which is especially useful for I/O-bound tasks.

Main features:

• thenApply, thenCompose, thenCombine — composition and combination of asynchronous tasks.
• exceptionally, handle — flexible error handling.
• supplyAsync, runAsync — executing tasks in a background thread pool (by default — ForkJoinPool.commonPool()).

Example of a CompletableFuture chain:

CompletableFuture.supplyAsync(() -> fetchUserFromDb(userId))
    .thenCompose(user -> fetchUserOrders(user))
    .thenAccept(orders -> sendEmail(userId, orders))
    .exceptionally(ex -> {
        log.error("Error fetching orders", ex);
        return null;
    });
  

The main advantage of CompletableFuture is the ability to not block threads. It eliminates the "one thread per request" model, allowing for easy scaling of systems that work with networks or files.

However, it is important to remember: the common pool ForkJoinPool.commonPool() can be blocked during intensive I/O tasks, so it's better to use your own Executor or move to a more modern model — virtual threads.

3️⃣ Virtual Threads (Project Loom)

Project Loom — a revolution in the Java multithreading model. Virtual threads are lightweight threads managed by the JVM, rather than the operating system. They allow creating thousands and even millions of parallel tasks with minimal resource overhead.

Advantages:

1. Scalability — thousands of tasks without fine-tuning thread pools.
2. simplicity — familiar synchronous code works in a non-blocking way.
3. Compatibility — support for older APIs: synchronized, ReentrantLock, Blocking I/O.

Example of Virtual Threads:

import java.util.List;
import java.util.concurrent.*;
import java.util.stream.IntStream;

public class VirtualThreadsExample {

    // Symbolic blocking operation — simulating I/O (e.g., HTTP request)
    static String doBlockingCall(int i) throws InterruptedException {
        Thread.sleep(100); // block the thread for 100 ms
        return "Result " + i + " from " + Thread.currentThread();
    }

    public static void main(String[] args) throws Exception {

        // ✅ Create a virtual pool — each task will get its own virtual thread.
        // This is the key feature of Project Loom.
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

        try {
            // Create 1000 tasks — regular threads would "choke" the system,
            // but virtual threads work smoothly, as they are managed by the JVM.
            List<Future<String>> futures = IntStream.range(0, 1000)
                    .mapToObj(i -> executor.submit(() -> doBlockingCall(i)))
                    .toList();

            // Get results — Future.get() blocks the thread,
            // but Loom parks the virtual thread without occupying the system one.
            for (Future<String> f : futures) {
                System.out.println(f.get());
            }

        } finally {
            // Shutdown the Executor to properly terminate execution.
            executor.shutdown();
        }
    }
}

Virtual threads are especially useful for mass I/O operations — for example, when processing HTTP requests or accessing external APIs. The code remains linear and readable, without callback hell.

4️⃣ How to Choose the Right Tool

In practice, a combination of approaches is often used: Fork/Join — for computations, CompletableFuture — for integration with external services, Loom — for scalable I/O operations.

Transition from Threads to Modern Tools

In the previous example, we created three threads manually. This helped to speed up order processing, but as the load increases, this approach quickly becomes a problem. If a thousand orders come in — we cannot start a thousand threads: the system will simply hit a limit.

"A thread is like if each order were handled by a separate employee. But if there are too many customers, you'll have to hire an army of people. Instead, we need a smart manager who distributes the tasks himself."

In Java, this role is performed by higher-level tools: ExecutorService, ForkJoinPool, and CompletableFuture. They manage a thread pool — that is, they keep a limited number of workers and assign them tasks as they become available.

Example using CompletableFuture:

import java.util.concurrent.CompletableFuture;

public class OrderProcessingSmart {
    public static void main(String[] args) {
        CompletableFuture
  
    order1 = CompletableFuture.runAsync(() -> processOrder("Order #1"));
        CompletableFuture
   
     order2 = CompletableFuture.runAsync(() -> processOrder("Order #2"));
        CompletableFuture
    
      order3 = CompletableFuture.runAsync(() -> processOrder("Order #3"));

        CompletableFuture.allOf(order1, order2, order3).join();
        System.out.println("All orders processed!");
    }

    private static void processOrder(String name) {
        System.out.println(name + " started " + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println(name + " completed " + Thread.currentThread().getName());
    }
}
  
    
   
  

Here, there is no need to manually create threads — the system itself decides how many workers to start, when to start them, and how to wait for all results. The code has become shorter, safer, and ready for real load.

On what basis CompletableFuture makes decisions

When you call CompletableFuture.runAsync() without specifying your own Executor, Java takes the tasks and sends them to the common pool — ForkJoinPool.commonPool(). This is a special mechanism that appeared in Java 7, which optimizes CPU usage.

Simply put, the JVM keeps several worker threads — usually as many as the processor has cores. And as soon as one thread is free, it "steals" a task from the queue of another thread (the Work-Stealing algorithm). This achieves almost full CPU utilization without idle time.

This is the fundamental difference from new Thread(). When you create threads manually, each thread lives on its own, takes up memory, and the JVM doesn’t know how to balance them. A pool is like a dispatcher: it monitors the state of the threads and decides for itself who to assign which task.

 CompletableFuture.runAsync(() -> processOrder("Order #1")); // executes inside ForkJoinPool.commonPool() 

But you can be even smarter: if you need to control the behavior of the pool — for example, allocate more threads for I/O or limit CPU-bound tasks, you pass your own ExecutorService:

 ExecutorService executor = Executors.newFixedThreadPool(4); CompletableFuture.runAsync(() -> processOrder("Order #1"), executor); CompletableFuture.runAsync(() -> processOrder("Order #2"), executor); 

Now the decisions about distribution are made not by the common JVM pool, but by your dedicated pool of four threads — this is already a business setting for a specific load or microservice.

So Java decides not at the level of "guessing what is better", but at the level of "maximally efficiently using available cores and tasks in the queue".

When Project Loom comes with virtual threads, the logic will remain the same, but the scheduler will be able to hold millions of tasks because virtual threads themselves do not take up system resources while waiting for I/O.

for (int i = 0; i < 10000; i++) {
    new Thread(() -> {
        System.out.println(Thread.currentThread().getName());
    }).start();
}
  

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10000; i++) {
        executor.submit(() -> {
            System.out.println(Thread.currentThread().getName());
        });
    }
}
  

var executor = Executors.newVirtualThreadPerTaskExecutor();
try {
    for (int i = 0; i < 10000; i++) {
        executor.submit(() -> httpCall());
    }
} finally {
    executor.shutdown();
}
  

Comparison of Approaches to Parallelism in Java and Prerequisites for Choosing

Conclusion

Java has evolved from classic multithreading to modern tools, capable of handling millions of parallel tasks. Mastery of all three approaches — Fork/Join Framework, CompletableFuture and Project Loom — distinguishes a mature developer who understands the nature of parallel computing, resource management, and the architecture of scalable systems.

An expert who masters these tools can:
— create efficient CPU algorithms;
— build asynchronous reactive chains;
— scale I/O-intensive applications to millions of connections.