java.util.concurrent: executors and CompletableFuture

Executors

An executor is a set of worker threads plus a queue. The Executors factory methods cover common shapes, but read what they do:

• newFixedThreadPool(n): n threads and an unbounded queue. Under overload, tasks pile up in memory and latency grows without limit.
• newCachedThreadPool(): reuses idle threads but creates new ones without limit. A burst can mean thousands of threads.
• newVirtualThreadPerTaskExecutor(): a virtual thread per task (Java 21, next topic).

For services, build the pool you mean:

1ExecutorService pool = new ThreadPoolExecutor(2    8, 8,                                        // core and maximum threads3    0, TimeUnit.SECONDS,4    new ArrayBlockingQueue<>(500),               // bounded queue5    new ThreadPoolExecutor.CallerRunsPolicy());  // when full, the submitter runs the task

When the queue is full the policy decides: throw RejectedExecutionException (the default), run the task on the caller's thread (which slows the producer down), or discard. Since Java 19 an ExecutorService is AutoCloseable: close() stops accepting tasks and waits for the submitted ones, so try-with-resources scopes a pool neatly.

CompletableFuture

1import java.util.concurrent.*;2 3public class Prices {4    static int price(String shop) {5        sleep(100);                       // stands in for a slow remote call6        return shop.length() * 10;7    }8 9    public static void main(String[] args) {10        try (ExecutorService pool = Executors.newFixedThreadPool(4)) {11            CompletableFuture<Integer> a = CompletableFuture.supplyAsync(() -> price("north"), pool);12            CompletableFuture<Integer> b = CompletableFuture.supplyAsync(() -> price("south-east"), pool);13 14            int best = a.thenCombine(b, Math::min)       // both run at once; combine when both finish15                        .orTimeout(2, TimeUnit.SECONDS)  // fail if it takes too long16                        .exceptionally(e -> -1)          // fallback on any failure17                        .join();18            System.out.println("best price: " + best);   // best price: 5019        }20    }21 22    static void sleep(long ms) {23        try { Thread.sleep(ms); } catch (InterruptedException e) { throw new RuntimeException(e); }24    }25}

The main combinators:

• thenApply(f): transform the value (like map).
• thenCompose(f): chain a step that returns another future (like flatMap).
• thenCombine(other, f): wait for two independent futures; allOf and anyOf for many.
• exceptionally, handle, whenComplete: deal with failure. An exception in any step skips the following value steps and arrives wrapped in a CompletionException.
• orTimeout and completeOnTimeout (Java 9): put a deadline on the whole chain.

Methods ending in Async without an executor argument run on ForkJoinPool.commonPool(), which the whole JVM shares, parallel streams included. It is sized for CPU work, roughly one thread per core, so blocking calls there starve everything else. Pass your own executor for anything that waits on I/O.

Other tools in the box

ConcurrentHashMap for shared maps, BlockingQueue for producer and consumer hand-offs, CountDownLatch and Semaphore for coordination, ReentrantLock when you need timeouts or try-lock that synchronized lacks. Prefer them to hand-written wait and notify.