java 43 lines · 8 steps

Exponential backoff retry in Java

A reusable executor retries a failing operation with exponentially growing, jittered delays until it succeeds or exhausts its attempts.

Explained by highlit

Intermediate retry exponential-backoff jitter generics concurrency

1public final class RetryExecutor {
2 
  private final int maxAttempts;
  private final Duration initialDelay;
  private final double multiplier;
  private final Duration maxDelay;
7 
  public RetryExecutor(int maxAttempts, Duration initialDelay, double multiplier, Duration maxDelay) {
      this.maxAttempts = maxAttempts;
      this.initialDelay = initialDelay;
      this.multiplier = multiplier;
      this.maxDelay = maxDelay;
  }
14 
  public <T> T execute(Callable<T> operation) throws Exception {
      Exception lastFailure = null;
      long delayMillis = initialDelay.toMillis();
18 
      for (int attempt = 1; attempt <= maxAttempts; attempt++) {
          try {
              return operation.call();
          } catch (Exception e) {
              lastFailure = e;
              if (attempt == maxAttempts) {
                  break;
              }
27 
              long jitter = ThreadLocalRandom.current().nextLong(delayMillis / 2 + 1);
              long sleep = Math.min(delayMillis + jitter, maxDelay.toMillis());
              try {
                  Thread.sleep(sleep);
              } catch (InterruptedException ie) {
                  Thread.currentThread().interrupt();
                  throw ie;
              }
36 
              delayMillis = (long) (delayMillis * multiplier);
          }
      }
40 
      throw new IllegalStateException("Operation failed after " + maxAttempts + " attempts", lastFailure);
  }
43}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1Exponential backoff spreads retries over widening intervals so a struggling dependency gets room to recover.
2Adding random jitter prevents many clients from retrying in lockstep and hammering a service simultaneously.
3Restoring the interrupt flag and rethrowing on InterruptedException keeps the operation responsive to cancellation.

Related explainers

java

@Component
public class RegionCacheWarmer implements SmartInitializingSingleton {
 
    private static final Logger log = LoggerFactory.getLogger(RegionCacheWarmer.class);

Warming a Spring cache at startup

caching startup-hook dependency-injection

Intermediate 7 steps

package breaker
 
import (
	"errors"

How a circuit breaker works in Go

circuit-breaker state-machine concurrency

Intermediate 8 steps

java

public final class EmailNormalizer {
 
    private static final Pattern EMAIL_PATTERN = Pattern.compile(
        "^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$"

Normalizing email addresses in Java

validation regex normalization

Intermediate 8 steps

ruby

module UniqueJob
  extend ActiveSupport::Concern
 
  class_methods do

Deduplicating Active Job enqueues in Rails

concurrency idempotency caching

Advanced 9 steps

java

@RestController
@RequestMapping("/api/products")
@RequiredArgsConstructor
public class ProductBatchController {

Batch JSON Merge Patch in Spring

json-merge-patch rest-api partial-update

Intermediate 8 steps

java

public class TimedFetchService {
 
    private final ExecutorService executor = Executors.newFixedThreadPool(8);
    private final HttpClient httpClient = HttpClient.newHttpClient();