Yarı Açık Durumun Amacı

Imagine a service you rely on suddenly fails. Your Circuit Breaker quickly opens, preventing further requests from hitting the downed service.

But how do you know when that service has recovered and is safe to call again? We can't keep the circuit open forever!

When a Circuit Breaker is in the Open state, it actively blocks all requests to the failing service. Instead, it fails fast, often returning an error or a fallback response immediately.

This protects the failing service from being overloaded and prevents your application from waiting indefinitely for a response.

After a service has been down for a while (and the circuit is Open), we need a way to check if it's back online without risking a full flood of requests that could crash it again.

This is where the Half-Open state comes into play. It's a cautious testing phase.

The Circuit Breaker doesn't stay Open indefinitely. After a configured reset timeout (e.g., 5 seconds, 1 minute), it automatically transitions from the Open state to the Half-Open state.

This timeout gives the failing service a chance to recover before we attempt to send requests again.

In the Half-Open state, the Circuit Breaker allows only a limited number of requests to pass through to the potentially recovered service.

• It's usually a small, configurable number (e.g., 1 to 5 requests).
• These are 'test' requests to gauge the service's health.

This simple code snippet shows how a Half-Open state might allow a limited number of requests to test a service's recovery:

If all (or a majority, depending on configuration) of the test requests sent during the Half-Open state are successful, the Circuit Breaker assumes the service has recovered.

It then transitions back to the Closed state, allowing all subsequent requests to pass through normally.

Conversely, if the test requests sent during the Half-Open state fail (e.g., throw an exception, timeout), it indicates the service is still unhealthy.

The Circuit Breaker immediately transitions back to the Open state, restarting the reset timeout to give the service more time to recover.

The Half-Open state is crucial for:

• Controlled Recovery: It allows services to recover gracefully without being overwhelmed by a sudden influx of requests.
• Preventing Overload: It avoids hammering a partially recovered or still-failing service.
• Timely Reconnection: It ensures your application reconnects to a healthy service as soon as possible.

Think of the Circuit Breaker states as a cycle:

• Closed: Everything is working.
• Open: Service failed, blocking requests.
• Half-Open: After a timeout, cautiously testing the service.
• If tests succeed, back to Closed.
• If tests fail, back to Open (and restart the timeout).

The Half-Open state is a vital part of the Circuit Breaker pattern, acting as a bridge between a failing service and its potential recovery.

It allows for a controlled, cautious re-evaluation of service health, ensuring that your application can quickly resume normal operation once a service is available again, without causing further instability.