Explain invokeAll and invokeAny on ExecutorService: their blocking and return semantics, how they handle exceptions and cancellation, and when you'd reach for each.

## The batch-submission methods Beyond submitting one task at a time, `ExecutorService` offers two methods that take an entire **collection of Callables** and coordinate them. Both are **blocking** — they don't return until a defined condition is met — which makes them convenient higher-level primitives over raw `submit` + manual `Future` juggling. Recall a **Callable<T>** is a task returning `T` (and may throw); a **Future<T>** is a handle to a pending result. ### invokeAll — run everything, wait for all ```java <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException; <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException; ``` - **Blocks** until **all** tasks finish (normally or by throwing), or the timeout elapses. - **Returns** a `List<Future<T>>` whose **order matches the input collection's iterator order** — element *i* of the result is the Future for the *i*-th task. This positional correspondence is the whole reason it's ergonomic. - Every returned Future is already **done**. To read results you iterate and call `get()` on each: a successful task's Future returns its value; a **failed task's** Future throws `ExecutionException` (cause = the original exception) from `get()`. So **invokeAll itself does not throw a task's exception** — failures are isolated *per Future*. One task failing does not stop the others. - **On timeout:** any tasks not finished by the deadline are **cancelled**; their Futures report `isCancelled() == true`, and `get()` throws `CancellationException`. This is the classic **scatter/gather** (fan-out/fan-in) primitive: split a job into N independent pieces, run them in parallel, wait, then collect ordered results. ### invokeAny — race, take the first success ```java <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException; <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; ``` - **Blocks** until **one** task completes **successfully**. - **Returns** that task's **result directly** — the raw `T`, *not* a Future. You don't get to know which task won. - As soon as one succeeds, the method **cancels all the other** still-running tasks (interrupting them) — they're no longer needed. - **If every task fails**, it throws `ExecutionException` (wrapping one of the failures). Tasks that fail are simply skipped while it waits for any other to succeed. - **On timeout:** throws `TimeoutException` if no task succeeded in time. This is the **racing/redundancy** primitive: when *any one* correct answer suffices and you want the fastest. Examples: query three database replicas and use whichever responds first; resolve a value from several caches/mirrors; hedge a slow request. ### Choosing between them | Need | Use | |---|---| | All results, in order, every task must run | `invokeAll` | | Just one result, fastest wins, cancel the rest | `invokeAny` | | Tolerate partial failure, inspect each outcome | `invokeAll` (per-Future) | | Redundant sources, want lowest latency | `invokeAny` | ### Interruption and the InterruptedException Both declare `throws InterruptedException` because they block the *calling* thread; if that thread is interrupted while waiting, they abort and (for invokeAll) cancel unfinished tasks. Always restore the interrupt status (`Thread.currentThread().interrupt()`) when you catch it. ### Worked example ```java List<Callable<Integer>> tasks = List.of( () -> slowLookup("a"), () -> slowLookup("b"), () -> slowLookup("c")); // invokeAll: ordered results, partial-failure tolerant List<Future<Integer>> futures = es.invokeAll(tasks); for (Future<Integer> f : futures) { try { use(f.get()); } catch (ExecutionException e) { log(e.getCause()); } // this task failed; others still fine } // invokeAny: first success wins, others cancelled Integer first = es.invokeAny(tasks); // throws ExecutionException only if ALL fail ``` ### Why these over manual submit loops You *could* call `submit` N times and loop over the Futures yourself. invokeAll/invokeAny package the common coordination (waiting, ordering, cancel-the-losers, timeout handling) into one call, reducing boilerplate and bugs — particularly the easy-to-get-wrong cancellation of losing tasks in the invokeAny case.