Coalesce concurrent Java loads for the same key

• The loader runs at most once for one in-flight key.
• Do not serialize unrelated keys behind one global lock.
• Every waiter receives the same value or underlying failure.
• Remove only the future owned by the completing invocation.
• Reject null keys and loader functions.

1. Create a new incomplete future for this invocation.
2. Use putIfAbsent to decide whether this caller owns the load.
3. If another future already exists, return that future without invoking the loader.
4. The owner runs the loader on the supplied executor and completes its future.
5. In finally, remove the mapping with remove(key, mine) so an older completion cannot remove a newer flight.

import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executor;
import java.util.function.Supplier;

public final class SingleFlight<K, V> {
    private final ConcurrentHashMap<K, CompletableFuture<V>> inFlight =
            new ConcurrentHashMap<>();
    private final Executor executor;

    public SingleFlight(Executor executor) {
        this.executor = Objects.requireNonNull(executor, "executor");
    }

    public CompletableFuture<V> load(K key, Supplier<V> loader) {
        Objects.requireNonNull(key, "key");
        Objects.requireNonNull(loader, "loader");

        var mine = new CompletableFuture<V>();
        var existing = inFlight.putIfAbsent(key, mine);
        if (existing != null) {
            return existing;
        }

        try {
            executor.execute(() -> {
                try {
                    mine.complete(loader.get());
                } catch (Throwable failure) {
                    mine.completeExceptionally(failure);
                } finally {
                    inFlight.remove(key, mine);
                }
            });
        } catch (RuntimeException schedulingFailure) {
            inFlight.remove(key, mine);
            mine.completeExceptionally(schedulingFailure);
        }
        return mine;
    }
}

Map coordination is expected O(1) per call. Memory is O(k + w), where k is the number of distinct in-flight keys and w is the number of waiting futures held by callers.

• A synchronous executor may complete and remove the flight before load returns; the returned future is still valid.
• A failed load is shared by current waiters but is not cached for later calls.
• Cancellation by one caller should not cancel the shared computation unless that policy is explicitly added.
• A loader that never completes keeps the key in flight, so real use also needs an operation timeout.

• Start many threads behind a barrier for one key and assert the loader counter is one.
• Block two different keys and prove both loaders enter concurrently.
• Fail the first load, then verify a later call invokes the loader again.
• Complete an old flight while a later flight exists and verify conditional removal preserves the newer entry.

• computeIfAbsent with a long blocking loader can hide difficult recursion and contention behavior.
• Calling plain remove(key) lets an old completion delete a newer in-flight value.
• A global synchronized block prevents useful concurrency across different keys.
• Keeping successful futures forever accidentally turns coalescing into an unbounded cache.