// 創(chuàng)建帶超時(shí)的 context
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
// 在請(qǐng)求中傳遞 context
req, _ := http.NewRequestWithContext(ctx, "GET", "http://service-a/api", nil)
resp, err := http.DefaultClient.Do(req)
if err != nil {
    // 超時(shí)或連接錯(cuò)誤處理
    log.Printf("request failed: %v", err)
    return
}
defer resp.Body.Close()

// 簡(jiǎn)化的狀態(tài)判斷邏輯
if failureCount > threshold {
    state = Open
    startTimeoutTimer()
} else if state == HalfOpen && success {
    state = Closed
    resetCounter()
}

package main
import (
    "fmt"
    "time"
    "github.com/afex/hystrix-go/hystrix"
)
func init() {
    hystrix.ConfigureCommand("remote-call", hystrix.CommandConfig{
        Timeout:                1000, // 超時(shí)時(shí)間（毫秒）
        MaxConcurrentRequests:  10,   // 最大并發(fā)數(shù)
        RequestVolumeThreshold: 5,    // 觸發(fā)熔斷的最小請(qǐng)求數(shù)
        SleepWindow:            5000, // 熔斷后等待時(shí)間
        ErrorPercentThreshold:  50,   // 錯(cuò)誤率閾值
    })
}
func remoteCall() error {
    return hystrix.Do("remote-call", func() error {
        // 模擬遠(yuǎn)程調(diào)用
        time.Sleep(800 * time.Millisecond)
        return nil
    }, func(err error) error {
        // 降級(jí)邏輯
        fmt.Println("觸發(fā)降級(jí)處理")
        return nil
    })
}

import "github.com/sony/gobreaker"
var cb = &gobreaker.CircuitBreaker{
    StateMachine: gobreaker.Settings{
        Name:        "UserService",
        MaxFailures: 3,
        Interval:    10 * time.Second,
        Timeout:     5 * time.Second,
    },
}
result, err := cb.Execute(func() (interface{}, error) {
    return callUserService()
})

HystrixCommandProperties.Setter()
    .withCircuitBreakerEnabled(true)
    .withCircuitBreakerRequestVolumeThreshold(20)
    .withCircuitBreakerErrorThresholdPercentage(50)
    .withCircuitBreakerSleepWindowInMilliseconds(5000);

circuitBreaker.WithLabelValues("payment-service").Set(1) // 狀態(tài)為1表示OPEN

// 偽代碼：降級(jí)判斷邏輯
func shouldDegraded(latency time.Duration, errRate float64) bool {
    if latency > 500*time.Millisecond && errRate > 0.05 {
        return true // 觸發(fā)綜合降級(jí)
    }
    return false
}

var cacheOnce sync.Once
var cacheInstance *RedisClient
var defaultData = map[string]string{"status": "degraded"}
func GetCache() map[string]string {
    cacheOnce.Do(func() {
        conn, err := dialRedis()
        if err != nil {
            log.Println("Redis unavailable, using default response")
            return
        }
        cacheInstance = conn
    })
    if cacheInstance == nil {
        return defaultData // 降級(jí)返回默認(rèn)值
    }
    return cacheInstance.Get("data")
}

ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
result, err := dependency.Call(ctx)
if err != nil {
    return fallbackResponse // 觸發(fā)降級(jí)
}

// 每分鐘最多允許100次請(qǐng)求
if currentTime.WindowStart == currentWindow.Start {
    if currentWindow.Count < 100 {
        currentWindow.Count++
        allow = true
    }
}

type LeakyBucket struct {
    capacity  int       // 桶容量
    water     int       // 當(dāng)前水量
    rate      time.Duration // 出水速率
    lastLeak  time.Time // 上次漏水時(shí)間
}
func (lb *LeakyBucket) Allow() bool {
    now := time.Now()
    leakedWater := int(now.Sub(lb.lastLeak) / lb.rate)
    if leakedWater > 0 {
        lb.water = max(0, lb.water-leakedWater)
        lb.lastLeak = now
    }
    if lb.water < lb.capacity {
        lb.water++
        return true
    }
    return false
}

type TokenBucket struct {
    capacity  int
    tokens    int
    rate      time.Duration
    lastToken time.Time
}
func (tb *TokenBucket) Allow() bool {
    now := time.Now()
    newTokens := int(now.Sub(tb.lastToken) / tb.rate)
    tb.tokens = min(tb.capacity, tb.tokens+newTokens)
    tb.lastToken = now
    if tb.tokens > 0 {
        tb.tokens--
        return true
    }
    return false
}

local key = KEYS[1]
local rate = tonumber(ARGV[1])        -- 令牌生成速率（個(gè)/秒）
local capacity = tonumber(ARGV[2])    -- 桶容量
local now = tonumber(ARGV[3])         -- 當(dāng)前時(shí)間戳（毫秒）
local fill_time = capacity / rate
local ttl = math.ceil(fill_time * 2)
local last_tokens = tonumber(redis.call('get', key) or capacity)
local last_time = tonumber(redis.call('get', key .. ':time') or now)
local delta = math.min(capacity, (now - last_time) / 1000 * rate)
local tokens = math.max(0, last_tokens + delta)
local allowed = tokens >= 1
if allowed then
    tokens = tokens - 1
    redis.call('set', key, tokens, 'PX', ttl * 1000)
    redis.call('set', key .. ':time', now, 'PX', ttl * 1000)
end
return { allowed, tokens }

// 使用滑動(dòng)窗口統(tǒng)計(jì)最近N秒請(qǐng)求
type SlidingWindow struct {
    windowSize int           // 窗口大?。耄?
    slots      []int         // 每秒請(qǐng)求數(shù)數(shù)組
    currentIndex int
}
func (sw *SlidingWindow) Increment() {
    now := time.Now().Second() % sw.windowSize
    if now != sw.currentIndex {
        sw.shiftSlots(now)
    }
    sw.slots[now]++
}

// 示例：Go 單元測(cè)試片段
func TestOrderService_CreateOrder(t *testing.T) {
    svc := NewOrderService(repoMock)
    order := &Order{Amount: 100.0, UserID: "user-123"}
    err := svc.Create(context.Background(), order)
    if err != nil {
        t.Errorf("expected no error, got %v", err)
    }
}