Doanh nghiệpEnterprise

Circuit Breakeraka Breaker, Fail Fast

Ngắt mạch khi dịch vụ phụ thuộc lỗi liên tục, trả lời nhanh bằng fallback thay vì chờ chết chùm.Trip the circuit when a dependency keeps failing and answer fast with a fallback instead of failing together.

Độ khóDifficulty: VừaMedium
Mức phổ biếnUsage: Mức phổ biếnUsage 5/5
Thời gian đọcReading time: ~9 phút đọc~9 min read

Thảo luậnDiscussion

Ví dụ đời thườngReal-life analogy

Cầu dao điện trong nhà: khi chập điện, cầu dao nhảy (OPEN) để cả căn nhà không cháy. Bạn đợi một lúc rồi bật thử (HALF_OPEN) — nếu ổn thì đóng lại bình thường (CLOSED), nếu vẫn chập thì nó nhảy tiếp. Không ai đứng giữ cầu dao cho nó khỏi nhảy cả.The breaker box in your house: on a short circuit it trips (OPEN) so the whole house doesn't burn. You wait a bit and flip it back to test (HALF_OPEN) — if all is fine it stays on (CLOSED), if it still shorts it trips again. Nobody holds the switch down to stop it tripping.

Vấn đề và giải phápProblem and solution

Không có patternWithout the pattern

Trang checkout gọi API GHN để tính phí ship. Một hôm GHN chậm 30 giây mỗi request: thread của Tomcat bị giữ hết để chờ, connection pool cạn, và trang checkout — vốn chẳng liên quan — cũng sập theo. Retry còn làm tệ hơn vì dội thêm request vào một service đang chết. Đây là lỗi dây chuyền (cascading failure).Checkout calls the GHN API to compute shipping fees. One day GHN takes 30 seconds per request: every Tomcat thread is stuck waiting, the connection pool dries up, and checkout — otherwise healthy — goes down too. Retries make it worse by piling more requests on a dying service. That's a cascading failure.

Với Circuit BreakerWith Circuit Breaker

Đặt một Circuit Breaker trước lời gọi GHN. Ở trạng thái CLOSED, nó đếm tỉ lệ lỗi/chậm trong một sliding window. Vượt ngưỡng → chuyển OPEN: mọi lời gọi bị từ chối ngay lập tức (vài micro-giây) và chạy fallback (phí ship cache hoặc phí cố định). Sau thời gian chờ → HALF_OPEN, cho vài request thử; thành công thì về CLOSED, thất bại thì OPEN lại.Put a Circuit Breaker in front of the GHN call. While CLOSED it tracks the failure/slow-call rate in a sliding window. Above the threshold → OPEN: every call is rejected immediately (microseconds) and the fallback runs (cached or flat shipping fee). After a wait → HALF_OPEN, letting a few trial calls through; success returns to CLOSED, failure goes back to OPEN.

Thành phần tham giaParticipants

Client: Code nghiệp vụ cần gọi dependency (CheckoutService).Business code that calls the dependency (CheckoutService).
Circuit Breaker: State machine CLOSED / OPEN / HALF_OPEN, quyết định cho gọi hay chặn.The CLOSED / OPEN / HALF_OPEN state machine deciding whether to allow or block calls.
Sliding window: Ghi nhận kết quả N lời gọi gần nhất để tính tỉ lệ lỗi/chậm.Records the last N call results to compute failure/slow rates.
Protected dependency: Service bên ngoài có thể chậm hoặc chết (GHN, Momo...).The remote service that may be slow or down (GHN, Momo...).
Fallback: Câu trả lời 'giảm cấp' khi mạch mở: cache, giá trị mặc định, thông báo thân thiện.The degraded answer while the circuit is open: cache, a default, a friendly message.

Sơ đồ và luồng thực thiDiagram and execution flow

Dùng Tự chạy hoặc phím mũi tên để đi qua từng bước gọi giữa các object. Console hiển thị output tương ứng của chương trình.Use Autoplay or the arrow keys to step through each call between objects. The console shows the matching program output.

1CLOSED: mọi request đi thẳng tới GHN, kết quả được ghi vào sliding window.CLOSED: every request goes straight to GHN, results are recorded in the sliding window.

← →

console

1[CLOSED] quote(district=1442) -> 22000

implementsimplementsextendsextendsgọi / dùngcalls / usestạo racreatesgửi qua channelsends via channel1thứ tự chạy (bấm để nhảy bước)execution order (click to jump)

Code: Java Spring Boot ⇄ GoCode: Java Spring Boot ⇄ Go

Cùng một bài toán, hai ngôn ngữ. Rê chuột hoặc focus vào chú thích (số màu cam) để làm nổi bật dòng code tương ứng.Same problem, two languages. Hover or focus an annotation (orange number) to highlight its line.

JavaSpring Boot 3 · Java 21Spring Boot 3 · Java 21

package com.shop.shipping;

import io.github.resilience4j.circuitbreaker.CallNotPermittedException;
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import java.math.BigDecimal;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestClient;

@Component
public class GhnFeeClient {
    private static final Logger log = LoggerFactory.getLogger(GhnFeeClient.class);
    private static final BigDecimal FLAT_FEE = new BigDecimal("30000");
    private final RestClient http;
    private final FeeCache cache;

    public GhnFeeClient(RestClient ghnRestClient, FeeCache cache) {
        this.http = ghnRestClient;
        this.cache = cache;
    }

    @CircuitBreaker(name = "ghn", fallbackMethod = "fallbackFee")1
    public BigDecimal quote(FeeRequest req) {
        FeeResponse res = http.post()
            .uri("/shiip/public-api/v2/shipping-order/fee")
            .body(req)
            .retrieve()
            .body(FeeResponse.class);
        cache.put(req.districtId(), res.total());2
        return res.total();
    }

    // Circuit is OPEN: GHN was not even called
    private BigDecimal fallbackFee(FeeRequest req, CallNotPermittedException ex) {3
        return cache.get(req.districtId()).orElse(FLAT_FEE);
    }

    // The call itself failed (timeout, 5xx...)
    private BigDecimal fallbackFee(FeeRequest req, Exception ex) {4
        log.warn("GHN fee failed for district {}: {}", req.districtId(), ex.toString());
        return cache.get(req.districtId()).orElse(FLAT_FEE);
    }
}

GoGo 1.23 · thư viện chuẩnGo 1.23 · standard library

package breaker

import (
	"errors"
	"sync"
	"time"
)

type State int

const (
	Closed State = iota
	Open
	HalfOpen
)

var ErrOpen = errors.New("circuit breaker is open")

// Simplified breaker: trips after N consecutive failures.
type Breaker struct {
	MaxFailures int
	CoolDown    time.Duration // how long to stay Open

	mu       sync.Mutex
	state    State
	failures int
	openedAt time.Time
	probing  bool // a Half-Open trial call is in flight
}

func (b *Breaker) Call(fn func() error) error {
	b.mu.Lock()
	if b.state == Open && time.Since(b.openedAt) >= b.CoolDown {1
		b.state = HalfOpen // cool-down over: allow one trial call
	}
	if b.state == Open || (b.state == HalfOpen && b.probing) {
		b.mu.Unlock()
		return ErrOpen // fail fast, no network call at all2
	}
	probe := b.state == HalfOpen
	b.probing = probe
	b.mu.Unlock()

	err := fn() // run outside the lock: a slow call must not block others3

	b.mu.Lock()
	defer b.mu.Unlock()
	if probe {
		b.probing = false
	}
	if err != nil {
		b.failures++
		if probe || b.failures >= b.MaxFailures {4
			b.state, b.openedAt = Open, time.Now()
		}
		return err
	}
	b.state, b.failures = Closed, 0
	return nil
}

Khác biệt chính giữa Java và GoKey differences between Java and Go

01Spring: @CircuitBreaker + application.yml, cấu hình đổi không cần sửa code. Go: breaker là một giá trị bạn tự tạo và gọi Execute — mọi thứ hiện rõ trong code.Spring: @CircuitBreaker + application.yml, tune without touching code. Go: the breaker is a value you create and call Execute on — everything is visible in code.
02fallbackMethod trong Java là một chuỗi tên method, gõ sai chỉ phát hiện lúc chạy. Go xử lý fallback bằng nhánh if/switch trên error — compiler kiểm tra giúp.Java's fallbackMethod is a method-name string, typos surface only at runtime. Go handles the fallback with an if/switch on the error — checked by the compiler.
03Resilience4j có sẵn sliding window theo số lượng/thời gian, slow-call rate, metrics Actuator/Micrometer. gobreaker đơn giản hơn: bạn tự viết ReadyToTrip từ Counts.Resilience4j ships count/time sliding windows, slow-call rate and Actuator/Micrometer metrics. gobreaker is simpler: you write ReadyToTrip from Counts yourself.
04Thread-safety: Resilience4j dùng cấu trúc lock-free bên trong. Bản Go tự viết dùng sync.Mutex và cố ý gọi hàm mạng NGOÀI lock.Thread safety: Resilience4j uses lock-free structures internally. The hand-rolled Go version uses sync.Mutex and deliberately calls the network OUTSIDE the lock.

Ứng dụng thực tếReal-world usage

Resilience4j (thay Netflix Hystrix)Resilience4j (successor of Netflix Hystrix)
Hystrix đã ngừng phát triển; Resilience4j là lựa chọn mặc định cho Spring Boot 3, tích hợp Spring Cloud CircuitBreaker, Actuator health và Micrometer.Hystrix is in maintenance mode; Resilience4j is the default choice for Spring Boot 3, integrating with Spring Cloud CircuitBreaker, Actuator health and Micrometer.
sony/gobreaker trong Gosony/gobreaker in Go
Thư viện breaker phổ biến nhất của Go, nhỏ gọn; bản v2 hỗ trợ generics. Nhiều team bọc nó trong http.RoundTripper để mọi request đều được bảo vệ.Go's most popular breaker library, tiny; v2 supports generics. Many teams wrap it in an http.RoundTripper so every request is protected.
Service mesh: Istio / EnvoyService mesh: Istio / Envoy
Envoy có outlier detection và connection limits — circuit breaking ở tầng hạ tầng, không cần sửa code ứng dụng.Envoy offers outlier detection and connection limits — circuit breaking at the infrastructure layer, no app code changes.
Sàn TMĐT ngày sale 11.11E-commerce 11.11 sale day
Khi dịch vụ gợi ý sản phẩm hay tính phí ship quá tải, breaker mở và trang vẫn hiển thị với dữ liệu mặc định — khách vẫn đặt hàng được.When the recommendation or shipping-fee service is overloaded, the breaker opens and the page still renders with defaults — customers can still order.

Khi nào dùng và khi nào khôngWhen to use it, and when not

Nên dùng khiUse it when

Gọi đồng bộ tới service/API bên ngoài có thể chậm hoặc chết, và bạn không muốn kéo sập cả hệ thống theo.Synchronous calls to remote services/APIs that may be slow or down, and you don't want them dragging your system down.
Có fallback hợp lý: cache, giá trị mặc định, tắt bớt tính năng phụ.There's a sensible fallback: cache, defaults, disabling a non-essential feature.
Muốn cho dependency 'thở' để hồi phục thay vì bị dội retry liên tục.You want to give the dependency room to recover instead of being hammered by retries.

Không nên dùng khiAvoid it when

Truy cập tài nguyên cục bộ trong process (map trong RAM, file local) — không có gì để 'ngắt'.Accessing in-process local resources (in-memory map, local file) — there's nothing to 'break'.
Xử lý bất đồng bộ qua hàng đợi — message tự chờ trong queue, consumer chỉ cần chậm lại.Asynchronous work via a queue — messages simply wait in the queue, the consumer just slows down.
Lỗi nghiệp vụ (sai dữ liệu) — không phản ánh sức khoẻ của dependency.Business errors (bad data) — they don't reflect the dependency's health.

Ưu điểmPros

Chặn lỗi dây chuyền: thread và connection không bị giữ chờ một service đang chết.Stops cascading failures: threads and connections aren't held waiting on a dead service.
Trả lời nhanh (fail fast) với fallback — trải nghiệm người dùng giảm cấp nhẹ nhàng.Fast answers (fail fast) with a fallback — graceful degradation for users.
Tự động thăm dò và phục hồi qua HALF_OPEN, không cần người can thiệp.Automatically probes and recovers via HALF_OPEN, no human needed.

Nhược điểmCons

Chọn ngưỡng khó: quá nhạy thì nhảy oan, quá lì thì bảo vệ không kịp.Thresholds are tricky: too sensitive trips falsely, too lenient protects too late.
Fallback có thể trả dữ liệu cũ/sai lệch (phí ship cache) — cần nghiệp vụ chấp nhận.Fallbacks may return stale data (cached fee) — the business must accept it.
Mỗi instance có breaker riêng nên trạng thái giữa các pod không đồng nhất.Each instance has its own breaker, so state differs between pods.

Anti-pattern: lỗi thường gặpAnti-pattern: common mistake

Một breaker cho mọi thứ + fallback nuốt lỗiOne breaker for everything + a fallback that swallows errors

Dùng chung một breaker tên "external" cho cả GHN, Momo và Zalo: Zalo chết kéo theo thanh toán Momo bị chặn. Fallback lại trả null không log gì, nên không ai biết mạch đang mở. Hãy tách breaker theo từng dependency và luôn log/alert khi chuyển trạng thái.Sharing one breaker named "external" for GHN, Momo and Zalo: Zalo going down blocks Momo payments too. The fallback returns null with no log, so nobody knows the circuit is open. Use one breaker per dependency and always log/alert on state changes.

@CircuitBreaker(name = "external", fallbackMethod = "fallback") // ❌ shared by all
public BigDecimal shippingFee(FeeRequest req) { return ghn.quote(req); }

@CircuitBreaker(name = "external", fallbackMethod = "fallback") // ❌ Zalo outage blocks payments
public PaymentResult pay(ChargeRequest req) { return momo.charge(req); }

private Object fallback(Object req, Throwable ex) {
    return null; // ❌ silent: no log, no alert, caller gets NPE later
}

Dễ nhầm vớiEasily confused with

Circuit Breaker vs Retry with Exponential Backoff

Retry: 'thử lại, chắc lần sau được'. Circuit Breaker: 'nó đang chết, ngừng gọi một lúc'. Retry nhân request lên, Breaker cắt request đi.Retry: 'try again, next time will work'. Circuit Breaker: 'it's down, stop calling for a while'. Retry multiplies requests, Breaker cuts them off.

Circuit Breaker vs Rate Limiter

Rate Limiter giới hạn số request theo thời gian bất kể dependency khoẻ hay không; Breaker phản ứng theo tỉ lệ lỗi thực tế.A Rate Limiter caps requests per time window regardless of health; a Breaker reacts to the observed failure rate.

Bài tập áp dụngExercise

Bảo vệ lời gọi tới dịch vụ gửi OTP qua SMS (ESMS): nếu ≥ 50% trong 20 lời gọi gần nhất lỗi thì ngắt mạch 60 giây; khi mạch mở, chuyển sang gửi OTP qua Zalo ZNS.Protect calls to the SMS OTP provider (ESMS): if ≥ 50% of the last 20 calls fail, open the circuit for 60 seconds; while open, send the OTP via Zalo ZNS instead.

Kiểm tra kiến thứcKnowledge check

Câu 1 / 5Question 1 of 5

Khi breaker đang OPEN, lời gọi mới sẽ thế nào?While the breaker is OPEN, what happens to a new call?

Phím 1–4 để chọn đáp án, Enter để kiểm tra.Press 1–4 to choose an answer, Enter to check.

Thẻ ghi nhớFlashcards

Ôn tập ngắt quãng (spaced repetition): thẻ được lặp lại sau 1 → 3 → 7 → 14 → 30 ngày để củng cố trí nhớ dài hạn.Spaced repetition: cards are repeated after 1 → 3 → 7 → 14 → 30 days to build long-term memory.

Dùng trong bài toánUsed in problems

1 bài toán Backend dùng pattern này1 backend problems use this pattern

Fault ToleranceFault ToleranceConcurrency & Phân tánConcurrency & distributed · SeniorSeniorSẵn sàngReady

Pattern liên quanRelated patterns

Retry with Exponential Backoff Proxy State Rate Limiter

Bài trướcPrevious

Retry with Exponential Backoff

Bài tiếpNext

CQRS

Thảo luậnDiscussion

Circuit Breakeraka Breaker, Fail Fast

VừaMedium

Mức phổ biếnUsage 5/5

~9 phút đọc~9 min read

package com.shop.shipping; import io.github.resilience4j.circuitbreaker.CallNotPermittedException; import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker; import java.math.BigDecimal; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Component; import org.springframework.web.client.RestClient; @Component public class GhnFeeClient { private static final Logger log = LoggerFactory.getLogger(GhnFeeClient.class); private static final BigDecimal FLAT_FEE = new BigDecimal("30000"); private final RestClient http; private final FeeCache cache; public GhnFeeClient(RestClient ghnRestClient, FeeCache cache) { this.http = ghnRestClient; this.cache = cache; } @CircuitBreaker(name = "ghn", fallbackMethod = "fallbackFee")1 public BigDecimal quote(FeeRequest req) { FeeResponse res = http.post() .uri("/shiip/public-api/v2/shipping-order/fee") .body(req) .retrieve() .body(FeeResponse.class); cache.put(req.districtId(), res.total());2 return res.total(); } // Circuit is OPEN: GHN was not even called private BigDecimal fallbackFee(FeeRequest req, CallNotPermittedException ex) {3 return cache.get(req.districtId()).orElse(FLAT_FEE); } // The call itself failed (timeout, 5xx...) private BigDecimal fallbackFee(FeeRequest req, Exception ex) {4 log.warn("GHN fee failed for district {}: {}", req.districtId(), ex.toString()); return cache.get(req.districtId()).orElse(FLAT_FEE); } }

package breaker import ( "errors" "sync" "time" ) type State int const ( Closed State = iota Open HalfOpen ) var ErrOpen = errors.New("circuit breaker is open") // Simplified breaker: trips after N consecutive failures. type Breaker struct { MaxFailures int CoolDown time.Duration // how long to stay Open mu sync.Mutex state State failures int openedAt time.Time probing bool // a Half-Open trial call is in flight } func (b *Breaker) Call(fn func() error) error { b.mu.Lock() if b.state == Open && time.Since(b.openedAt) >= b.CoolDown {1 b.state = HalfOpen // cool-down over: allow one trial call } if b.state == Open || (b.state == HalfOpen && b.probing) { b.mu.Unlock() return ErrOpen // fail fast, no network call at all2 } probe := b.state == HalfOpen b.probing = probe b.mu.Unlock() err := fn() // run outside the lock: a slow call must not block others3 b.mu.Lock() defer b.mu.Unlock() if probe { b.probing = false } if err != nil { b.failures++ if probe || b.failures >= b.MaxFailures {4 b.state, b.openedAt = Open, time.Now() } return err } b.state, b.failures = Closed, 0 return nil }

@CircuitBreaker(name = "external", fallbackMethod = "fallback") // ❌ shared by all public BigDecimal shippingFee(FeeRequest req) { return ghn.quote(req); } @CircuitBreaker(name = "external", fallbackMethod = "fallback") // ❌ Zalo outage blocks payments public PaymentResult pay(ChargeRequest req) { return momo.charge(req); } private Object fallback(Object req, Throwable ex) { return null; // ❌ silent: no log, no alert, caller gets NPE later }