go-resiliency - Golang实现弹性设计模式的插件库

go-resiliency是一个实现了多种弹性设计模式的Golang库，部分基于Hystrix和Semian等项目的思想。

当前实现的模式包括

1. 断路器模式 (在breaker目录中)
2. 信号量模式 (在semaphore目录中)
3. 截止时间/超时模式 (在deadline目录中)
4. 批处理模式 (在batcher目录中)
5. 可重试模式 (在retrier目录中)

完整示例Demo

1. 断路器模式示例

package main

import (
	"fmt"
	"time"
	"github.com/eapache/go-resiliency/breaker"
)

func main() {
	// 创建一个断路器，错误率达到50%时触发，最少需要5个请求才能触发
	b := breaker.New(5, 0.5, time.Second*5)

	for i := 0; i < 10; i++ {
		// 使用断路器执行可能失败的操作
		result := b.Run(func() error {
			// 模拟失败的操作 - 每两次调用失败一次
			if i%2 == 0 {
				return fmt.Errorf("模拟错误")
			}
			return nil
		})

		switch result {
		case nil:
			fmt.Printf("调用 %d 成功\n", i)
		case breaker.ErrBreakerOpen:
			fmt.Printf("调用 %d 被断路器阻止\n", i)
		default:
			fmt.Printf("调用 %d 失败: %v\n", i, result)
		}
	}
}

2. 超时模式示例

package main

import (
	"context"
	"fmt"
	"time"
	"github.com/eapache/go-resiliency/deadline"
)

func main() {
	// 创建一个500ms的超时器
	dl := deadline.New(500 * time.Millisecond)

	// 在超时上下文中执行长时间运行的操作
	err := dl.Run(func(ctx context.Context) error {
		// 模拟长时间运行的操作
		select {
		case <-time.After(1 * time.Second):
			fmt.Println("操作完成")
			return nil
		case <-ctx.Done():
			return ctx.Err() // 返回超时错误
		}
	})

	if err != nil {
		fmt.Println("错误:", err) // 预期输出: 错误: context deadline exceeded
	}
}

3. 可重试模式示例

package main

import (
	"fmt"
	"time"
	"github.com/eapache/go-resiliency/retrier"
)

func main() {
	// 创建一个重试器，最多重试3次，使用指数退避策略
	r := retrier.New(retrier.ExponentialBackoff(3, 100*time.Millisecond), nil)

	// 执行可能失败的操作
	err := r.Run(func() error {
		// 模拟失败的操作
		return fmt.Errorf("模拟错误")
	})

	if err != nil {
		fmt.Println("最终失败:", err) // 预期输出: 最终失败: 模拟错误
	}
}

4. 信号量模式示例

package main

import (
	"fmt"
	"sync"
	"time"
	"github.com/eapache/go-resiliency/semaphore"
)

func main() {
	// 创建一个最大并发数为2的信号量
	s := semaphore.New(2)

	var wg sync.WaitGroup

	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()

			// 获取信号量许可
			if err := s.Acquire(); err != nil {
				fmt.Printf("goroutine %d 获取信号量失败\n", id)
				return
			}
			defer s.Release()

			fmt.Printf("goroutine %d 开始工作\n", id)
			time.Sleep(1 * time.Second)
			fmt.Printf("goroutine %d 完成工作\n", id)
		}(i)
	}

	wg.Wait()
}

5. 批处理模式示例

package main

import (
	"fmt"
	"time"
	"github.com/eapache/go-resiliency/batcher"
)

func main() {
	// 创建一个批处理器，最多等待100ms或收集10个项
	b := batcher.New(100*time.Millisecond, 10)

	// 启动批处理器
	go b.Run(func(items []interface{}) error {
		fmt.Printf("处理批处理: %v\n", items)
		return nil
	})

	// 添加项目到批处理器
	for i := 0; i < 15; i++ {
		b.Batch(i)
		time.Sleep(20 * time.Millisecond)
	}

	time.Sleep(200 * time.Millisecond) // 等待所有批处理完成
}

注意：该库会偶尔提升最低要求的Golang版本而不提升主版本号，这违反了官方Golang打包约定。通常被放弃的版本都是多年未维护的旧版本。