Lesson 47 of 59

5 mins read

Future Combinators: wait, any, delayed & timeout

In Plain English

When an application needs to coordinate multiple independent asynchronous tasks, **Future Combinators** provide parallel orchestration: **`Future.wait()`** executes multiple futures concurrently and waits for all to finish; **`Future.any()`** returns the fastest winner; **`Future.delayed()`** creates timer delays; and **`.timeout()`** aborts long-hanging network calls.

The Mental Model

"`Future.wait()` is like sending three couriers out simultaneously to pick up pizza, drinks, and dessert: you wait until all three couriers return with their bags before setting the dinner table."

Deep Dive: How It Works

`Future.wait([f1, f2, f3])`: Runs tasks concurrently, completing with a `List<T>` containing all results.

`Future.any([f1, f2])`: Returns the result of whichever future completes first, discarding slower results.

`.timeout(Duration)`: Throws a `TimeoutException` if the future does not complete within the specified window.

Syntax Blueprint

// Concurrent execution
final results = await Future.wait([
  fetchUserProfile(),
  fetchUserPosts(),
  fetchNotifications(),
]);

// Timeout guard
final fastData = await fetchRpc().timeout(Duration(seconds: 2));

Concurrent multi-future coordination and timeout protection.

Core Rules to Remember

Concurrent Acceleration: `Future.wait` runs tasks in parallel rather than serially awaiting each.

Race Condition (Future.any): Query multiple mirrors and use the fastest responding node.

Timeout Protection: Prevents stalled network requests from hanging application state.

Common Beginner Traps & How to Fix Them

Mistake:Awaiting futures sequentially in a loop when they are independent (`await f1; await f2;`).

Why it happens: Doubles or triples total latency unnecessarily.

How to fix: Launch them concurrently with `Future.wait([f1, f2])`.

Pro Tip: Use `Future.wait(eagerError: false)` if you want all futures to complete even if one throws an error.

Live Interactive Example

Hit Run Code to see it live

Concurrent Task Execution with Future.wait

Python 3.12

Output Console

Click "Run Code" to view the rendered output.

How it works: Both services were probed concurrently and consolidated into a unified result list.

Your Turn: Micro Challenge

No pressure! Edit the starter code below and test your solution with instant feedback.

Micro Exercise

Coordinate Parallel Futures

Create two async functions returning ints: `f1` (returns 10) and `f2` (returns 20).
In `main() async`, execute `final results = await Future.wait([f1(), f2()]);`.
Print `Total: ${results[0] + results[1]}`.

Sandbox Output

Click "Run & Check" to test your solution.

Finished reading and practicing?

Mark this lesson as completed to update your course progress.