What is Circuit Breaker pattern?

Question

Accepted Answer

**Circuit Breaker** — a resilience pattern that prevents cascading failures by detecting when a downstream service is failing and short-circuiting calls to it, allowing the failing service to recover.

**System Design Context:**
In a microservices architecture, Service A depends on Service B, which depends on Service C. If Service C is slow or down, Service B waits, consuming threads. Service A then waits for Service B, and the entire chain fails. The circuit breaker stops this cascade.

**Three States:**
- **Closed** — requests pass through normally. Failures are counted. When failure rate exceeds threshold, circuit opens.
- **Open** — requests fail immediately without calling the downstream service. After a timeout, transitions to half-open.
- **Half-Open** — a limited number of test requests pass through. If they succeed, circuit closes. If they fail, circuit opens again.

**Resilience4j — Production Implementation:**
```java
@Service
@Slf4j
public class OrderService {

private final WebClient webClient;
    private final CircuitBreaker circuitBreaker;
    private final Retry retry;

public OrderService(WebClient.Builder builder,
                        CircuitBreakerRegistry cbRegistry,
                        RetryRegistry retryRegistry) {
        this.webClient = builder.baseUrl("http://user-service").build();
        this.circuitBreaker = cbRegistry.circuitBreaker("userService");
        this.retry = retryRegistry.retry("userService");
    }

@CircuitBreaker(name = "userService", fallbackMethod = "fallbackGetUser")
    @Retry(name = "userService")
    public User getUser(Long userId) {
        return webClient.get()
            .uri("/api/users/{id}", userId)
            .retrieve()
            .bodyToMono(User.class)
            .block();
    }

public User fallbackGetUser(Long userId, Exception e) {
        log.warn("Circuit breaker fallback for user {}: {}", userId, e.getMessage());
        return User.defaultValue();
    }

// Event listeners for observability
    @EventConsumer
    public void onCircuitBreakerEvent(CircuitBreakerEvent event) {
        log.info("Circuit breaker event: {} - {}", event.getEventType(),
            event.getCircuitBreaker().getName());
    }
}

# application.yml
resilience4j:
  circuitbreaker:
    instances:
      userService:
        failureRateThreshold: 50
        slowCallRateThreshold: 100
        slowCallDurationThreshold: 2s
        slidingWindowSize: 10
        slidingWindowSizeType: COUNT_BASED
        minimumNumberOfCalls: 5
        waitDurationInOpenState: 10s
        permittedNumberOfCallsInHalfOpenState: 3
        automaticTransitionFromOpenToHalfOpenEnabled: true
        registerHealthIndicator: true
  retry:
    instances:
      userService:
        maxAttempts: 3
        waitDuration: 500ms
        enableExponentialBackoff: true
        exponentialBackoffMultiplier: 2
        retryExceptions:
          - java.io.IOException
          - java.util.concurrent.TimeoutException
```

**Scaling Patterns:**
- **Bulkhead** — isolate thread pools per service to prevent one failing service from consuming all threads.
- **Rate Limiter** — limit calls to prevent overload.
- **Time Limiter** — set maximum wait time for responses.

**Common Pitfalls:**
- **Wrong threshold** — too sensitive causes unnecessary tripping, too lenient allows cascading. Fix: tune based on actual failure rates.
- **Missing fallback** — circuit opens but no fallback defined. Fix: always provide a fallback method.
- **Ignoring slow calls** — service responds slowly but doesn't fail. Fix: configure slow call detection.

**Monitoring:**
- Track **circuit state transitions** (closed → open → half-open).
- Monitor **fallback invocation rate**.
- Alert on **prolonged open state** (> 5 minutes).
- Dashboard: Resilience4j metrics → Prometheus → Grafana.

Java: What is Circuit Breaker pattern?