Synchronization

Enables retrieval of a background task's outcome by blocking until the computation finishes or fails.

Concurrent execution: after submitting a callable to an executor and needing its return value; Pipeline orchestration: when a downstream step depends on a background computation's output; Error propagation: when exceptions from worker threads must be surfaced in the main thread.

Python standard library concurrent.futures module; any code using Futures from asyncio (though asyncio.Future has result() as well); frameworks that expose Future-like objects.

future.result(timeout=None)

future.result(...)

timeout: float or int specifying seconds to wait (optional)

• concurrent.futures.ThreadPoolExecutor
• ProcessPoolExecutor
• executor.submit
• add_done_callback
• as_completed

• future.result(timeout=seconds) — trades indefinite wait for a TimeoutError if the task is slow
• future.exception() — retrieves only the exception without re-raising
• useful for conditional error handling
• concurrent.futures.as_completed(futures) — processes results as they arrive rather than blocking on one at a time.

Calling result() on the main thread inside a callback submitted to the same executor — causes deadlock because the worker cannot be scheduled; Assuming result() is non-blocking — it suspends the calling thread indefinitely by default, freezing the program; Not catching exceptions from result() — the re-raised exception propagates up and crashes the caller if unhandled; Using result() inside an asyncio event loop on an asyncio.Future — blocks the loop and prevents other coroutines from running.

future.exception() returns exception if any; future.done() checks completion without blocking; asyncio.await future (non-blocking yield).

Coming from JavaScript Promises: expecting .result() to be non-blocking like .then(); → in Python it blocks the thread.

• Future-based synchronization
• executor submission
• callback registration

Do not call result() on a Future inside a callback running on the same executor — it deadlocks. Blocking the calling thread means no other work proceeds on that thread, which can degrade throughput in GUI or server applications. If timeout is 0, the call raises TimeoutError immediately unless the Future is already done, which is a non-obvious way to poll completion without waiting.

Ensures synchronization between producer and consumer threads; simplifies error propagation from background work.

Think of 'future.result()' as 'get the fruit of the labor'.

Calling result() blocks the calling thread until the future completes or the timeout expires; if the future completed with an exception, result() re-raises that exception; calling result() multiple times returns the same result or raises the same exception.

Use asyncio.Future with await for non‑blocking result, or concurrent.futures.as_completed to handle multiple futures efficiently.