在 Gin 中实现请求并发限制（也称为并发访问控制）可以通过编写自定义中间件来限制同一时间内能够处理的最大并发请求数。这个中间件可以使用信号量（semaphore）的方式来控制并发请求数，超出限制的请求会被拒绝或者排队等待。
我们可以使用 Go 的 sync 包中的 Semaphore 或者 chan 来限制并发请求。以下是一个使用 chan 实现并发请求限制的示例：
Life is like a journey
chan 实现并发请求限制package main
import (
"fmt"
"github.com/gin-gonic/gin"
"net/http"
"time"
)
// 并发限制中间件
func ConcurrencyLimiter(maxConcurrency int) gin.HandlerFunc {
// 创建一个容量为 maxConcurrency 的通道，用来限制并发
semaphore := make(chan struct{}, maxConcurrency)
return func(c *gin.Context) {
// 如果通道已满，则表示并发量已达上限，拒绝请求
select {
case semaphore <- struct{}{}:
// 启动了一个请求，继续处理
c.Next()
// 请求处理完后释放一个并发信号
<-semaphore
default:
// 如果并发量已达上限，拒绝请求并返回 429 状态码
c.JSON(http.StatusTooManyRequests, gin.H{
"message": "Too many requests, please try again later.",
})
c.Abort() // 终止请求处理
}
}
}
func main() {
// 创建 Gin 实例
r := gin.Default()
// 使用并发限制中间件，最大并发请求数设置为 2
r.Use(ConcurrencyLimiter(2))
// 示例路由
r.GET("/example", func(c *gin.Context) {
// 模拟处理请求的时间
time.Sleep(2 * time.Second)
c.JSON(http.StatusOK, gin.H{
"message": "Request processed successfully",
})
})
// 启动服务器
r.Run(":8080")
}
ConcurrencyLimiter 中间件：
maxConcurrency 的通道（semaphore）来限制并发请求的数量。每当有请求进入时，程序会尝试向通道发送一个信号（semaphore <- struct{}{}）。如果通道未满，表示可以处理该请求，继续执行 c.Next()。Too Many Requests 错误。<-semaphore），允许其他请求继续执行。maxConcurrency 参数：
maxConcurrency 控制最大并发请求数。在上面的例子中，最大并发请求数设置为 2，意味着在同一时间只能有 2 个请求被处理。如果有超过 2 个请求并发到达，超出的请求会被拒绝，并返回 429 错误。运行该程序后，尝试发送多个请求：
正常请求（并发请求数未超过限制）：
curl http://localhost:8080/example
超过并发限制的请求（如同时发起多个请求）：
curl http://localhost:8080/example
curl http://localhost:8080/example
假设最大并发限制为 2，那么只有前两个请求会被处理，第三个请求会收到如下响应：
{
"message": "Too many requests, please try again later."
}
为了模拟请求的处理延迟，可以在路由处理函数中使用 time.Sleep() 来延迟响应。例如，模拟请求需要处理 2 秒钟：
time.Sleep(2 * time.Second) // 模拟处理请求的延迟
除了使用 chan 方式实现并发限制，还可以使用其他方法，例如：
sync.WaitGroup 或 sync.Mutex：
sync.Mutex 来加锁限制并发，但这种方式可能会导致更多的内存开销，并且不如 chan 高效。通过在 Gin 中实现并发限制中间件，你可以控制并发请求的数量，避免服务器因为超载而崩溃。这对于高并发场景和防止恶意攻击（例如 DDoS）非常有帮助。可以通过信号量、通道、令牌桶等方式实现这一功能。