Golang分布式应用速率限制与分布式锁配置插件库limiters使用指南

一、limiters库简介

limiters是一个强大的Go库，专门用于实现分布式系统中的速率限制和分布式锁功能。它支持多种后端存储(Redis、内存等)和多种限流算法，非常适合构建高可用、可扩展的分布式系统。

二、安装limiters库

go get github.com/mennanov/limiters

三、速率限制实现

1. 基于Redis的令牌桶限流

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/mennanov/limiters"
	"github.com/redis/go-redis/v9"
)

func main() {
	// 初始化Redis客户端
	client := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
	})

	// 创建令牌桶限流器
	// 参数说明: 10 tokens/s, 最大容量100 tokens
	limiter := limiters.NewTokenBucketRedis(
		"my-rate-limiter", // 唯一标识
		client,
		10,               // 每秒补充的令牌数
		100,              // 桶容量
		limiters.SystemClock{},
	)

	ctx := context.Background()

	// 模拟请求
	for i := 0; i < 20; i++ {
		// 尝试获取1个令牌
		w, err := limiter.Limit(ctx)
		if err != nil {
			panic(err)
		}

		if w == 0 {
			fmt.Printf("Request %d: Allowed\n", i+1)
		} else {
			fmt.Printf("Request %d: Denied, wait %v\n", i+1, w)
			time.Sleep(w)
			i-- // 重试当前请求
		}

		time.Sleep(50 * time.Millisecond) // 模拟请求间隔
	}
}

2. 滑动窗口限流

func slidingWindowExample() {
	client := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
	})

	// 创建滑动窗口限流器
	// 参数说明: 每秒最多100个请求，窗口大小1秒
	limiter := limiters.NewSlidingWindowRedis(
		"sliding-window-limiter",
		client,
		100,               // 最大请求数
		time.Second,       // 窗口大小
		limiters.SystemClock{},
	)

	ctx := context.Background()

	for i := 0; i < 120; i++ {
		w, err := limiter.Limit(ctx)
		if err != nil {
			panic(err)
		}

		if w == 0 {
			fmt.Printf("Request %d: Allowed\n", i+1)
		} else {
			fmt.Printf("Request %d: Denied, wait %v\n", i+1, w)
			time.Sleep(w)
			i-- // 重试当前请求
		}

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

四、分布式锁实现

1. 基本分布式锁

func distributedLockExample() {
	client := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
	})

	// 创建分布式锁
	lock := limiters.NewLockRedis(
		client,
		"my-distributed-lock",
		limiters.SystemClock{},
	)

	ctx := context.Background()

	// 尝试获取锁
	ttl := 10 * time.Second // 锁的TTL
	locked, err := lock.Lock(ctx, ttl)
	if err != nil {
		panic(err)
	}

	if locked {
		defer lock.Unlock(ctx) // 确保释放锁
		fmt.Println("成功获取分布式锁")
		// 执行关键代码
		time.Sleep(5 * time.Second)
		fmt.Println("关键操作完成")
	} else {
		fmt.Println("获取锁失败，其他进程持有锁")
	}
}

2. 带重试的分布式锁

func retryLockExample() {
	client := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
	})

	lock := limiters.NewLockRedis(
		client,
		"retry-lock",
		limiters.SystemClock{},
	)

	ctx := context.Background()
	ttl := 5 * time.Second

	// 带重试机制的获取锁
	maxRetries := 3
	retryDelay := 1 * time.Second

	for i := 0; i < maxRetries; i++ {
		locked, err := lock.Lock(ctx, ttl)
		if err != nil {
			panic(err)
		}

		if locked {
			defer lock.Unlock(ctx)
			fmt.Println("成功获取锁")
			// 执行业务逻辑
			return
		}

		fmt.Printf("尝试 %d/%d 获取锁失败，等待重试...\n", i+1, maxRetries)
		time.Sleep(retryDelay)
	}

	fmt.Println("达到最大重试次数，无法获取锁")
}

五、高级配置

1. 自定义限流器配置

func customLimiter() {
	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // 设置密码
		DB:       1,  // 使用DB1
	})

	// 自定义令牌桶配置
	limiter := limiters.NewTokenBucketRedis(
		"custom-limiter",
		client,
		20,                // 速率
		200,               // 容量
		limiters.SystemClock{},
		limiters.WithTokenBucketRedisPrefix("custom:"), // 自定义Redis key前缀
		limiters.WithTokenBucketRedisMaxRetries(5),     // 最大重试次数
	)
	
	// 使用限流器...
}

2. 组合使用限流器和锁

func combinedExample() {
	client := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
	})

	// 创建限流器
	limiter := limiters.NewTokenBucketRedis(
		"api-rate-limiter",
		client,
		50,
		500,
		limiters.SystemClock{},
	)

	// 创建分布式锁
	lock := limiters.NewLockRedis(
		client,
		"resource-lock",
		limiters.SystemClock{},
	)

	ctx := context.Background()

	// 先限流
	w, err := limiter.Limit(ctx)
	if err != nil {
		panic(err)
	}
	if w > 0 {
		time.Sleep(w)
	}

	// 再获取锁
	locked, err := lock.Lock(ctx, 10*time.Second)
	if err != nil {
		panic(err)
	}
	if !locked {
		fmt.Println("无法获取资源锁")
		return
	}
	defer lock.Unlock(ctx)

	// 执行业务逻辑
	fmt.Println("执行业务逻辑...")
}

六、最佳实践

1. 合理设置限流参数：根据业务需求调整速率和容量
2. 锁的TTL：总是为锁设置合理的TTL，防止死锁
3. 错误处理：妥善处理限流和锁获取失败的情况
4. 监控：监控限流和锁的使用情况，及时调整配置
5. 降级策略：当Redis不可用时，考虑降级到本地限流/锁

limiters库提供了强大的分布式限流和锁功能，通过合理配置可以显著提高分布式系统的稳定性和可靠性。