Equal Jitter Backoff

Resilience Patterns

Meaning

Equal jitter backoff is a retry delay algorithm that combines exponential growth with a deterministic half‑delay and a random half‑delay. It addresses the thundering‑herd problem by spreading retries over a bounded interval. It is used when a client must retry an operation after a transient failure and wants to avoid synchronized bursts of traffic.

Primary Function

Retry strategy

Communicative Purpose

Mitigates thundering‑herd spikes by randomizing retry intervals while keeping a predictable minimum delay.

Pattern

calculate backoff → add equal jitter → sleep

Core Structure

sleep = backoff/2 + random(0, backoff/2)

Função primária

Retry strategy

Propósito comunicativo

Mitigates thundering‑herd spikes by randomizing retry intervals while keeping a predictable minimum delay.

Situações de gatilho

Distributed systems: retrying failed HTTP requests after transient errors; Microservices: handling HTTP 429 rate‑limit responses; Message queues: reprocessing messages after a temporary broker outage

Contextos

Cloud services, client libraries, networking code, distributed job schedulers, API clients

Padrão

calculate backoff → add equal jitter → sleep

Estrutura central

sleep = backoff/2 + random(0, backoff/2)

Colocados típicos

exponential backoff
random jitter
retry loop
circuit breaker
backoff cap

Substituições comuns

full jitter backoff – uses only random delay
more variance
decorrelated jitter – changes backoff each attempt
avoids long tails
fixed delay – constant interval
simpler but can cause synchronized retries

Erros comuns

Using equal jitter without a maximum cap → backoff can grow unbounded; Adding jitter twice (full + equal) → delays become excessive; Miscalculating backoff/2 with integer division → loss of precision and shorter delays

Similar / contraste

Full jitter backoff – replaces the deterministic half with full randomness; Decorrelated jitter – recomputes backoff based on previous delay, reducing correlation; Fixed delay – constant interval, no exponential growth

Interferências

Coming from JavaScript: using setTimeout with a constant delay → misses jitter benefits — replace with equal jitter calculation; Coming from Bash scripts: relying on sleep without randomness → can cause synchronized retries — implement equal jitter algorithm instead

Família do chunk

Exponential backoff
Full jitter backoff
Decorrelated jitter backoff
Retry loop
Circuit breaker

Nuance

1) Do not use when strict timing guarantees are required, such as real‑time control loops. 2) The algorithm adds negligible CPU overhead; the random number generation is cheap. 3) Ensure the backoff value is capped to avoid integer overflow or excessively long sleeps.

Efeito pragmático

Reduces load spikes on services, improves overall system stability, and prevents cascading failures during outages.

Dica de memória

Equal jitter backoff is like splitting a crowd: half wait a fixed time, the other half wait a random extra, so arrivals are staggered.

Nota

Choose a cryptographically secure RNG only when security matters; otherwise, the standard pseudo‑random generator is sufficient.

Upgrade path

Implement decorrelated jitter backoff for even lower synchronization risk

Frequência: MediumFormulaicidade: FixedTipo de construção: algorithmPrioridade de aquisição: Active recallPrioridade de output: BothTag de espaçamento: Short-term

Examples

import random import time def equal_jitter_backoff(attempt, base=0.5, cap=30): backoff = min(cap, base * (2 ** attempt)) return backoff / 2 + random.uniform(0, backoff / 2) for i in range(5): delay = equal_jitter_backoff(i) print(f"Attempt {i}: sleeping {delay:.2f}s") time.sleep(delay)

import random import time import requests def equal_jitter_backoff(attempt, base=1, cap=60): backoff = min(cap, base * (2 ** attempt)) return backoff / 2 + random.uniform(0, backoff / 2) def fetch_with_retry(url, max_attempts=5): for attempt in range(max_attempts): try: response = requests.get(url) response.raise_for_status() return response.text except requests.RequestException: if attempt == max_attempts - 1: raise delay = equal_jitter_backoff(attempt) time.sleep(delay) data = fetch_with_retry("https://example.com/api") print(data[:100])

import random import asyncio import aiohttp async def equal_jitter_backoff(attempt, base=0.5, cap=30): backoff = min(cap, base * (2 ** attempt)) return backoff / 2 + random.uniform(0, backoff / 2) async def fetch(session, url, attempt=0, max_attempts=5): try: async with session.get(url) as resp: resp.raise_for_status() return await resp.text() except Exception: if attempt >= max_attempts - 1: raise delay = await equal_jitter_backoff(attempt) await asyncio.sleep(delay) return await fetch(session, url, attempt + 1, max_attempts) async def main(): async with aiohttp.ClientSession() as session: html = await fetch(session, "https://example.com") print(html[:100]) asyncio.run(main())