timeout pattern

Resilience Patterns

Meaning

A timeout pattern defines a way to limit the maximum execution time of a block of code. It addresses the pain point of operations that may hang or run longer than acceptable, which can degrade system responsiveness or waste resources. Developers reach for it when they need to guarantee that a function, request, or task aborts after a specified duration.

Primary Function

Control flow

Communicative Purpose

Prevents long-running operations from exceeding allocated time limits, ensuring system responsiveness.

Pattern

start operation → set timeout → if timeout expires abort operation → handle timeout exception

Função primária

Control flow

Propósito comunicativo

Prevents long-running operations from exceeding allocated time limits, ensuring system responsiveness.

Situações de gatilho

Web service: handling a request that may block indefinitely; Data pipeline: aborting a slow batch job; CLI tool: enforcing a maximum execution time for a command.

Contextos

Network services, batch processing scripts, command-line utilities, asynchronous frameworks like asyncio.

Padrão

start operation → set timeout → if timeout expires abort operation → handle timeout exception

Colocados típicos

timeout decorator
alarm signal
context manager
watchdog timer

Substituições comuns

using threading.Timer instead of signal.alarm for portability
using asyncio.wait_for for async code
wrapping code in a custom context manager for reusable timeout handling

Erros comuns

Assuming signal.alarm works on Windows → raises NotImplementedError; Forgetting to cancel a timer thread → it may fire after the operation completed; Using timeout on code that blocks in C extensions → the Python-level timeout cannot interrupt it

Similar / contraste

circuit breaker pattern – focuses on failure rates, not execution time; retry pattern – repeats failed operations instead of aborting after a time limit

Interferências

Coming from JavaScript: using setTimeout to pause execution → it schedules a callback without blocking, which does not enforce a timeout in Python code

Família do chunk

retry pattern
circuit breaker
backoff strategy

Nuance

Do not use this pattern for CPU‑bound code that cannot be interrupted by signals; the overhead is minimal (a few microseconds for setting an alarm); timeouts may not trigger inside native extensions that ignore Python signals

Efeito pragmático

Ensures services stay responsive and resources are reclaimed, preventing hangs that could cascade into larger outages

Dica de memória

A timeout is like a kitchen timer that dings to stop the stew before it burns.

Frequência: HighFormulaicidade: FixedTipo de construção: patternPrioridade de aquisição: Active recallPrioridade de output: BothTag de espaçamento: Immediate

Examples

import signal class TimeoutException(Exception): pass def _handle_timeout(signum, frame): raise TimeoutException() signal.signal(signal.SIGALRM, _handle_timeout) def fetch_data(): signal.alarm(5) # 5‑second timeout try: result = slow_io_operation() finally: signal.alarm(0) # cancel alarm return result

import concurrent.futures def fetch_with_timeout(func, timeout, *args, **kwargs): with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor: future = executor.submit(func, *args, **kwargs) return future.result(timeout=timeout) # usage result = fetch_with_timeout(slow_io_operation, 5)

import asyncio async def fetch_data(): await asyncio.sleep(10) # simulate long operation async def main(): try: await asyncio.wait_for(fetch_data(), timeout=5) except asyncio.TimeoutError: print('Operation timed out') asyncio.run(main())