Golang 服务熔断机制：Circuit Breaker 使用指南

熔断器模式是微服务架构中重要的稳定性保障机制，可以有效防止服务雪崩效应。在 Go 生态中，circuitbreaker 是一个优秀的熔断器实现库。

安装 circuitbreaker

go get github.com/rubyist/circuitbreaker

基本使用示例

package main

import (
	"fmt"
	"time"
	"github.com/rubyist/circuitbreaker"
)

func main() {
	// 创建熔断器实例
	cb := circuit.NewThresholdBreaker(3) // 3次失败后熔断

	// 模拟服务调用
	for i := 0; i < 10; i++ {
		// 使用熔断器保护服务调用
		err := cb.Call(func() error {
			// 这里是实际的服务调用逻辑
			if i < 5 {
				return fmt.Errorf("模拟服务失败")
			}
			return nil
		}, 1*time.Second) // 设置超时时间

		if err != nil {
			fmt.Printf("调用失败: %v, 熔断状态: %v\n", err, cb.State())
		} else {
			fmt.Printf("调用成功, 熔断状态: %v\n", cb.State())
		}

		time.Sleep(500 * time.Millisecond)
	}
}

高级配置

func advancedExample() {
	// 创建可配置的熔断器
	cb := circuit.NewRateBreaker(0.5, 10) // 失败率50%以上触发，最少10次调用

	// 自定义配置
	cb = &circuit.Breaker{
		ShouldTrip: circuit.ThresholdTripFunc(5), // 5次失败后熔断
		WindowTime: 10 * time.Second,            // 统计窗口时间
		Timeout:    2 * time.Second,             // 超时时间
		ReadyToTrip: func(counts circuit.Counts) bool {
			// 自定义熔断触发条件
			return counts.ConsecFailures >= 3 || 
				(counts.Total >= 10 && counts.FailRate() >= 0.6)
		},
		OnStateChange: func(oldState, newState circuit.State) {
			// 状态变更回调
			fmt.Printf("状态变更: %s -> %s\n", oldState, newState)
		},
	}

	// 使用熔断器
	for i := 0; i < 15; i++ {
		err := cb.Call(func() error {
			if i%3 == 0 { // 模拟1/3的失败率
				return fmt.Errorf("服务错误")
			}
			return nil
		}, 0) // 0表示使用熔断器默认超时

		if err != nil {
			fmt.Printf("调用失败: %v, 状态: %v, 统计: %+v\n", 
				err, cb.State(), cb.Counts())
		} else {
			fmt.Printf("调用成功, 状态: %v\n", cb.State())
		}

		time.Sleep(300 * time.Millisecond)
	}
}

实际应用场景

package main

import (
	"context"
	"fmt"
	"net/http"
	"time"
	"github.com/rubyist/circuitbreaker"
)

var cb = circuit.NewThresholdBreaker(3)

func protectedAPICall(url string) (string, error) {
	var result string
	err := cb.Call(func() error {
		// 创建带超时的HTTP客户端
		client := &http.Client{
			Timeout: 2 * time.Second,
		}
		
		// 创建带超时的请求上下文
		ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
		defer cancel()
		
		req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
		if err != nil {
			return err
		}
		
		resp, err := client.Do(req)
		if err != nil {
			return err
		}
		defer resp.Body.Close()
		
		if resp.StatusCode != http.StatusOK {
			return fmt.Errorf("HTTP错误: %s", resp.Status)
		}
		
		// 处理响应...
		result = "处理后的响应数据"
		return nil
	}, 0) // 0表示使用熔断器默认超时

	return result, err
}

func main() {
	for i := 0; i < 10; i++ {
		res, err := protectedAPICall("https://example.com/api")
		if err != nil {
			fmt.Printf("API调用失败: %v (状态: %v)\n", err, cb.State())
		} else {
			fmt.Printf("API调用成功: %s (状态: %v)\n", res, cb.State())
		}
		
		time.Sleep(1 * time.Second)
	}
}

最佳实践

1. 合理设置熔断阈值：根据服务特点设置失败次数或失败率阈值
2. 监控熔断状态：通过 State() 方法监控熔断器状态变化
3. 设置合理的超时时间：防止长时间阻塞
4. 熔断恢复策略：熔断器会自动尝试半开状态恢复，但可以自定义恢复逻辑
5. 结合重试机制：可以与重试机制配合使用，但要注意重试次数和熔断阈值的协调

总结

circuitbreaker 库提供了简单而强大的熔断器实现，通过合理配置可以显著提高系统的稳定性。在实际应用中，应该根据服务特点和业务需求调整熔断策略，并结合监控系统实时跟踪熔断状态。