golang框架限流和熔断与微服务架构的最佳匹配方式

package main

import (
    "fmt"
    "sync"
    "time"
)

// 令牌桶限流器
type TokenBucketLimiter struct {
    mu               sync.Mutex
    capacity         int // 令牌桶容量
    availableTokens  int // 可用令牌数量
    tokensPerSecond int // 每秒生成的令牌数量

    // 定时生成新令牌
    ticker *time.Ticker
}

// NewTokenBucketLimiter 创建一个新的令牌桶限流器
func NewTokenBucketLimiter(capacity, tokensPerSecond int) *TokenBucketLimiter {
    return &TokenBucketLimiter{
        capacity:         capacity,
        availableTokens:  capacity,
        tokensPerSecond: tokensPerSecond,
        ticker:           time.NewTicker(1 * time.Second / time.Duration(tokensPerSecond)),
    }
}

// AcquireToken 尝试获取一个令牌
func (limiter *TokenBucketLimiter) AcquireToken() bool {
    limiter.mu.Lock()
    defer limiter.mu.Unlock()

    if limiter.availableTokens == 0 {
        return false
    }

    limiter.availableTokens--
    return true
}

func main() {
    limiter := NewTokenBucketLimiter(10, 5)

    for i := 0; i < 100; i++ {
        if limiter.AcquireToken() {
            // 处理请求
            fmt.Println(i)
        } else {
            // 限制请求
            fmt.Println("请求被限制！")
        }
    }
}

package main

import (
    "fmt"
    "sync"
    "time"
)

// 熔断器
type CircuitBreaker struct {
    mu           sync.Mutex
    state        State // 当前状态
    lastError    error // 上次错误
    failureCount int   // 失败次数
    timeout      time.Duration // 熔断打开后的重试时间
}

// 状态枚举
type State int

const (
    Closed State = iota
    Open
    HalfOpen
)

// NewCircuitBreaker 创建一个新的熔断器
func NewCircuitBreaker(timeout time.Duration) *CircuitBreaker {
    return &CircuitBreaker{
        state:   Closed,
        timeout: timeout,
    }
}

// Execute 执行操作，并根据熔断器状态进行处理
func (breaker *CircuitBreaker) Execute(f func() error) error {
    breaker.mu.Lock()
    defer breaker.mu.Unlock()

    switch breaker.state {
    case Closed:
        err := f()
        if err != nil {
            breaker.fail(err)
        }
        return err

    case Open:
        return breaker.lastError

    case HalfOpen:
        breaker.failureCount = 0
        err := f()
        if err != nil {
            breaker.fail(err)
            return err
        }
        breaker.close()
        return err
    }

    return nil
}

// fail 失败时进行处理
func (breaker *CircuitBreaker) fail(err error) {
    breaker.state = Open
    breaker.failureCount++
    breaker.lastError = err
    time.AfterFunc(breaker.timeout, func() { breaker.halfOpen() })
}

// halfOpen 重试时进行处理
func (breaker *CircuitBreaker) halfOpen() {
    breaker.state = HalfOpen
}

// close 成功时进行处理
func (breaker *CircuitBreaker) close() {
    breaker.state = Closed
}

func main() {
    breaker := NewCircuitBreaker(5 * time.Second)

    for i := 0; i < 10; i++ {
        err := breaker.Execute(func() error { return fmt.Errorf("failed") })
        if err != nil {
            fmt.Println(err)
        } else {
            fmt.Println("成功！")
        }
    }
}