限流、熔断库sentinel-golang

限流

文档

github链接
官方文档

简单示例

package main

import (
	sentinel "github.com/alibaba/sentinel-golang/api"
	"github.com/alibaba/sentinel-golang/core/base"
	"github.com/alibaba/sentinel-golang/core/flow"
	"log"
)

func main() {
	if err := sentinel.InitDefault();err != nil {
		log.Fatal(err)
	}

	_, err := flow.LoadRules([]*flow.Rule{
		{
			Resource:               "test",
			TokenCalculateStrategy: flow.Direct,
			ControlBehavior:        flow.Reject,	//流量超过阈值就拒绝
			Threshold:              10,		//阈值
			StatIntervalInMs:       1000,	//流量统计周期
		},
	})
	if err != nil {
		log.Fatalf("Unexpected error: %+v", err)
		return
	}

	for i := 0;i<12;i++ {
		e,err := sentinel.Entry("test",sentinel.WithTrafficType(base.Inbound))
		if err != nil {
			log.Println(err)
			continue
		}
		log.Println("没出错")
		e.Exit()
	}
}

预热（冷启动）方式

当系统长期处于低水位的情况下，当流量突然增加时，直接把系统拉升到高水位可能瞬间把系统压垮。通过"冷启动"，让通过的流量缓慢增加，在一定时间内逐渐增加到阈值上限，给冷系统一个预热的时间，避免冷系统被压垮。

package main

import (
	"fmt"
	sentinel "github.com/alibaba/sentinel-golang/api"
	"github.com/alibaba/sentinel-golang/core/base"
	"github.com/alibaba/sentinel-golang/core/flow"
	"log"
	"sync"
	"time"
)

func main() {
	if err := sentinel.InitDefault(); err != nil {
		log.Fatal(err)
	}

	_, err := flow.LoadRules([]*flow.Rule{
		{
			Resource:               "test",
			TokenCalculateStrategy: flow.WarmUp, // 预热模式
			ControlBehavior:        flow.Reject,
			WarmUpPeriodSec:        5, // 预热时间
			WarmUpColdFactor:       6, // 预热因子，默认是 3
			Threshold:              800,
			StatIntervalInMs:       1000,
		},
	})
	if err != nil {
		log.Fatalf("Unexpected error: %+v", err)
		return
	}

	var passCount int
	var lock sync.Mutex
	for i := 0; i < 8; i++ {
		go func() {
			for  {
				e, err := sentinel.Entry("test", sentinel.WithTrafficType(base.Inbound))
				if err != nil {
					continue
				}
				e.Exit()
				lock.Lock()
				passCount ++
				lock.Unlock()
			}
		}()

	}
	for i:=1;i<=10;i++{
		pre := passCount
		time.Sleep(time.Second)
		cur := passCount

		fmt.Printf("第 %d 秒通过数量 %d \n",i,cur-pre)
	}
}

$ go run warmup.go
第 1 秒通过数量 281
第 2 秒通过数量 169
第 3 秒通过数量 200
第 4 秒通过数量 257
第 5 秒通过数量 391
第 6 秒通过数量 800
第 7 秒通过数量 800
第 8 秒通过数量 801
第 9 秒通过数量 800
第 10 秒通过数量 802

排队策略

package main

import (
	"fmt"
	sentinel "github.com/alibaba/sentinel-golang/api"
	"github.com/alibaba/sentinel-golang/core/base"
	"github.com/alibaba/sentinel-golang/core/flow"
	"log"
	"sync"
	"time"
)

func main() {
	if err := sentinel.InitDefault(); err != nil {
		log.Fatal(err)
	}

	_, err := flow.LoadRules([]*flow.Rule{
		{
			Resource:               "test",
			TokenCalculateStrategy: flow.Direct,
			ControlBehavior:        flow.Throttling,
			Threshold:              100, // 排队时间是 1000/100 = 10ms
			StatIntervalInMs:       1000,
			MaxQueueingTimeMs:      100, // 允许的最长排队等待时间，默认0，直接拒绝,设置此项sentinel.Entry会阻塞等待
		},
	})
	if err != nil {
		log.Fatalf("Unexpected error: %+v", err)
		return
	}
	start := time.Now()
	var wg sync.WaitGroup
	for i := 0; i < 20; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			e, err := sentinel.Entry("test", sentinel.WithTrafficType(base.Inbound))
			if err != nil {
				fmt.Print("拒绝  ")
				return
			}
			fmt.Print("通过 ")
			e.Exit()
		}()
	}
	wg.Wait()
	fmt.Println()
	fmt.Printf("时长：%v", time.Since(start))
}

结果：

$ go run Throttling.go
通过 拒绝  拒绝  拒绝  拒绝  拒绝  拒绝  拒绝  拒绝  拒绝  通过 通过 通过 通过 通过 通过 通过 通过 通过 通过
时长：101.8116ms

可以看到，当并发收到20个请求时，9个请求立刻被拒绝，10个请求加入了排队，阻塞等待，根据 Threshold （排队时间）进行后续的请求处理