executor.submit(task_func, *args, **kwargs).add_done_callback

Concurrency & Async

Meaning

Submits a callable to an Executor for asynchronous execution and registers a callback to be invoked when the resulting Future completes.

Primary Function

Submit a task to an Executor and attach a completion callback.

Communicative Purpose

Express the intent to run a function asynchronously and specify what should happen when it finishes.

Pattern

executor.submit(task_func, *args, **kwargs).add_done_callback(callback)

Core Structure

executor.submit(task_func, *args, **kwargs).add_done_callback(callback)

Função primária

Submit a task to an Executor and attach a completion callback.

Propósito comunicativo

Express the intent to run a function asynchronously and specify what should happen when it finishes.

Situações de gatilho

When you need to run a function concurrently and want to be notified of its completion, e.g., to update UI, log results, or chain further asynchronous work.

Contextos

Used with concurrent.futures.ThreadPoolExecutor or ProcessPoolExecutor in concurrent programming scenarios.

Padrão

executor.submit(task_func, *args, **kwargs).add_done_callback(callback)

Estrutura central

executor.submit(task_func, *args, **kwargs).add_done_callback(callback)

Slots de substituição

executor (Executor instance), task_func (callable), *args (positional arguments), **kwargs (keyword arguments), callback (callable accepting a Future)

Colocados típicos

Executor
Future
submit
add_done_callback
callback
args
kwargs
future

Substituições comuns

Using lambda for callback
using functools.partial to pre‑bind arguments
using future.result() instead of a callback
attaching add_done_callback directly to the Future returned by submit

Erros comuns

Failing to retain the Future returned by submit (causing the callback to be dropped), providing a callback that does not accept the Future argument, performing blocking work inside the callback, misunderstanding that the callback receives the Future, not the result directly.

Similar / contraste

Similar to blocking on future.result(); contrasted with executor.map for simple parallelism and with asyncio.create_task/await for async/await style.

Interferências

Coming from JavaScript: may expect the callback to receive the resolved value directly → Python's add_done_callback always receives the Future object, requiring an explicit .result() call inside the callback. Coming from threading.Thread: may assume the callback runs in the main thread → callbacks execute in the worker thread that completed the Future, not the calling thread.

Família do chunk

concurrent.futures callback pattern

Nuance

When NOT to use: when you need the result immediately and blocking is acceptable; Performance implications: minimal overhead for callback setup, but blocking in callback can degrade throughput; Boundary conditions: callback executes even if task is cancelled, and receives the Future object regardless of outcome.

Efeito pragmático

Sets up asynchronous completion handling, enabling non‑blocking continuation of work after a task finishes.

Dica de memória

Submit then callback when done.

Nota

The callback is invoked with the Future instance; ensure it does not perform blocking operations unless intended.

Upgrade path

Consider using concurrent.futures.as_completed or asyncio for more complex coordination; for simple map‑like patterns use executor.map.

Frequência: MediumFormulaicidade: Semi-fixedTipo de construção: method chainingPrioridade de aquisição: Active recallPrioridade de output: OutputTag de espaçamento: Medium-term

Examples

from concurrent.futures import ThreadPoolExecutor def fetch_url(url): import urllib.request return urllib.request.urlopen(url).read() def on_fetch_done(future): try: data = future.result() print(f"Fetched {len(data)} bytes") except Exception as exc: print(f"Fetch failed: {exc}") with ThreadPoolExecutor(max_workers=4) as pool: pool.submit(fetch_url, "https://example.com").add_done_callback(on_fetch_done)

from concurrent.futures import ThreadPoolExecutor import hashlib def compute_hash(filepath): with open(filepath, "rb") as f: return hashlib.sha256(f.read()).hexdigest() def log_hash(future): result = future.result() print(f"SHA-256: {result}") with ThreadPoolExecutor(max_workers=2) as pool: pool.submit(compute_hash, "/tmp/data.bin").add_done_callback(log_hash)

from concurrent.futures import ThreadPoolExecutor import json def load_config(path): with open(path) as f: return json.load(f) def on_config_loaded(future): try: config = future.result() print(f"Config loaded: {config.get('app_name', 'unknown')}") except Exception as exc: print(f"Config load error: {exc}") with ThreadPoolExecutor(max_workers=2) as pool: pool.submit(load_config, "settings.json").add_done_callback(on_config_loaded)