In the world of concurrent programming, we often face scenarios where we need to perform the same task in multiple ways, but we only care about the first successful result. Imagine querying three different microservices for the same piece of data. You don’t care which service responds, as long as you get the data as quickly as possible. Once you have it, the other requests become redundant.

How do you efficiently manage this “race”? You could manually spin up threads, use a CountDownLatch or a Phaser, and manage a shared result variable with locks. But that’s complicated and error-prone. Fortunately, Java’s ExecutorService provides a clean, powerful, and built-in solution: the invokeAny() method.

Let’s dive into how invokeAny() works and how you can use it to write cleaner, more efficient concurrent code.

What is ExecutorService.invokeAny()?

The invokeAny() method is a blocking operation that submits a collection of Callable tasks to an ExecutorService. It doesn’t wait for all of them to finish. Instead, it waits for the first task to complete successfully (i.e., without throwing an exception) and returns its result.

As soon as one task finishes, invokeAny() returns its result and immediately attempts to cancel all other running or pending tasks.

This “fire-and-forget-the-rest” behavior makes it the perfect tool for tasks involving redundancy and speed.

When to Use invokeAny()? (The “Why”)

The use cases for invokeAny() are surprisingly common. Here are a few scenarios where it shines:

• Querying Redundant Services: You have multiple identical or similar microservices, APIs, or database replicas. You can send a request to all of them simultaneously and use the response from whichever one replies first, improving your application’s latency and fault tolerance.
• Finding the Fastest Resource: Imagine downloading a file from several mirror servers. You can create a Callable for each server and let invokeAny() pick the fastest download stream.
• Competing Algorithms: If you have multiple algorithms to solve the same problem, you can run them in parallel and take the result from the one that finishes first. This is useful when algorithm performance varies based on the input data.

The invokeAny() Method Signatures

The ExecutorService interface provides two variants of the invokeAny() method:

1. T invokeAny(Collection> tasks)
   This version blocks indefinitely until one of the tasks completes successfully.
2. T invokeAny(Collection> tasks, long timeout, TimeUnit unit)
   This version blocks for a specified timeout. If no task completes within the given time, it throws a TimeoutException.

Using the timed version is highly recommended in production environments to prevent your application from hanging indefinitely if all tasks are slow or unresponsive.

Practical Example 1: Basic invokeAny() Usage

Let’s simulate fetching a user profile from three different APIs. Each API has a different response time. We only want the first profile we get.

First, we’ll create our Callable task, which simulates a network call.

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

// A Callable task that simulates fetching data from a remote API
class ApiClientTask implements Callable<String> {
    private final String clientName;
    private final long responseTimeInMillis;

    public ApiClientTask(String clientName, long responseTimeInMillis) {
        this.clientName = clientName;
        this.responseTimeInMillis = responseTimeInMillis;
    }

    @Override
    public String call() throws Exception {
        System.out.println(clientName + ": Starting fetch...");
        // Simulate network latency
        TimeUnit.MILLISECONDS.sleep(responseTimeInMillis);
        System.out.println(clientName + ": Finished fetch!");
        return "Result from " + clientName;
    }
}

Now, let’s use invokeAny() to run three instances of this task and see which one wins the race.

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class InvokeAnyBasicExample {
    public static void main(String[] args) {
        // Use a fixed-size thread pool
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // Create a list of tasks with varying response times
        List<ApiClientTask> tasks = List.of(
            new ApiClientTask("API-A", 2000), // Slowest
            new ApiClientTask("API-B", 1000), // Fastest
            new ApiClientTask("API-C", 1500)  // Medium
        );

        try {
            System.out.println("Submitting all tasks and waiting for the first result...");
            
            // This call blocks until the *first* task (API-B) completes
            String fastestResult = executor.invokeAny(tasks);
            
            System.out.println("========================================");
            System.out.println("Fastest result received: " + fastestResult);
            System.out.println("========================================");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // Always shut down the executor
            executor.shutdown();
            System.out.println("
Executor service has been shut down.");
        }
    }
}

Expected Output and Analysis

Submitting all tasks and waiting for the first result...
API-A: Starting fetch...
API-B: Starting fetch...
API-C: Starting fetch...
API-B: Finished fetch!

========================================
Fastest result received: Result from API-B
========================================

Executor service has been shut down.

As you can see, all three tasks started execution. However, API-B had the shortest simulated delay (1000ms), so it finished first. As soon as it completed, invokeAny() returned its result (“Result from API-B”) and the program continued. The other two tasks, API-A and API-C, were cancelled and their results were discarded.

Practical Example 2: invokeAny() with a Timeout

What if you can’t afford to wait forever? Let’s modify the previous example to use a timeout that is shorter than our fastest task’s execution time. This will force a TimeoutException.

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class InvokeAnyTimeoutExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        List<ApiClientTask> tasks = List.of(
            new ApiClientTask("API-A", 2000),
            new ApiClientTask("API-B", 1000),
            new ApiClientTask("API-C", 1500)
        );

        try {
            System.out.println("Submitting tasks with a 500ms timeout...");
            
            // This will throw a TimeoutException because the fastest task takes 1000ms
            String fastestResult = executor.invokeAny(tasks, 500, TimeUnit.MILLISECONDS);
            
            System.out.println("Fastest result received: " + fastestResult);

        } catch (TimeoutException e) {
            System.err.println("========================================");
            System.err.println("Operation timed out! No service responded within 500ms.");
            System.err.println("========================================");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executor.shutdownNow(); // Use shutdownNow() to interrupt running tasks
            System.out.println("
Executor service has been shut down.");
        }
    }
}

Expected Output and Analysis

Submitting tasks with a 500ms timeout...
API-A: Starting fetch...
API-B: Starting fetch...
API-C: Starting fetch...

========================================
Operation timed out! No service responded within 500ms.
========================================

Executor service has been shut down.

Here, we set a timeout of 500 milliseconds. Since our fastest task (API-B) needs 1000ms to complete, the timeout was exceeded, and a TimeoutException was thrown. This is crucial for building responsive systems that don’t get stuck waiting for slow downstream dependencies.

Important Considerations and Caveats

• Exception Handling: What if all submitted tasks fail by throwing an exception? In this case, invokeAny() will also throw an exception. It will propagate an ExecutionException, which wraps the exception thrown by the last task to fail.
• Blocking Nature: Remember that invokeAny() is a blocking call. The thread that calls it will be paused until a result is available, an exception is thrown, or a timeout occurs.
• Task Cancellation: Cancellation is on a “best-effort” basis. invokeAny() calls Future.cancel(true) on the other tasks, which sends an interrupt signal. If your Callable tasks do not handle InterruptedException, they might run to completion anyway, consuming resources.

Conclusion: Key Takeaways

The ExecutorService.invokeAny() method is a powerful concurrency utility that simplifies a common pattern: racing multiple tasks to get the first available result.

Remember these key points:

• Use for Speed and Redundancy: It’s perfect for when you have multiple ways to get the same result and you want the fastest one.
• Returns First Successful Result: It returns the result of the first Callable to complete without an exception.
• Cancels Other Tasks: It automatically attempts to cancel all other running tasks, saving resources.
• Always Use Timeouts: In production code, prefer the timed version invokeAny(tasks, timeout, unit) to prevent indefinite blocking.
• Be Ready for Exceptions: Prepare to handle TimeoutException (if no task finishes in time) and ExecutionException (if all tasks fail).

By mastering invokeAny(), you can write more robust, efficient, and resilient concurrent applications in Java. Happy coding!