syncx.Limit

syncx 包提供了一种管理并发请求的限流机制。通过定义一个 Limit 类型，可以控制同时进行的请求数量。

变量

ErrLimitReturn

  1. var ErrLimitReturn = errors.New("discarding limited token, resource pool is full, someone returned multiple times")

ErrLimitReturn 表示当归还的元素超过借用的数量时，资源池已满的错误信息。

类型

Limit

  1. type Limit struct {
  2.     pool chan lang.PlaceholderType
  3. }

Limit 是一个包含带缓冲通道 pool 的结构体，用于控制并发请求的数量。

函数

NewLimit

  1. func NewLimit(n int) Limit

NewLimit 创建一个可以同时借用 n 个元素的 Limit 实例。

参数

  • n (int): 可同时借用的元素数量。

返回值

  • Limit: 一个新的 Limit 实例。

Borrow

  1. func (l Limit) Borrow()

Borrow 方法以阻塞模式借用一个元素。

Return

  1. func (l Limit) Return() error

Return 方法归还借用的资源。如果归还的资源超过借用的数量，则返回错误 ErrLimitReturn。

返回值

  • error: 如果归还成功返回 nil，否则返回 ErrLimitReturn 错误。

TryBorrow

  1. func (l Limit) TryBorrow() bool

TryBorrow 方法以非阻塞模式尝试借用一个元素。

返回值

  • bool: 如果成功借用，返回 true，否则返回 false。

用法示例

  1. package main
  3. import (
  4.     "fmt"
  5.     "log"
  6.     "syncx"
  7. )
  9. func main() {
  10.     limit := syncx.NewLimit(2)
  12.     if limit.TryBorrow() {
  13.         fmt.Println("Successfully borrowed the first token.")
  14.     } else {
  15.         fmt.Println("Failed to borrow the first token.")
  16.     }
  18.     if limit.TryBorrow() {
  19.         fmt.Println("Successfully borrowed the second token.")
  20.     } else {
  21.         fmt.Println("Failed to borrow the second token.")
  22.     }
  24.     if limit.TryBorrow() {
  25.         fmt.Println("Successfully borrowed the third token.")
  26.     } else {
  27.         fmt.Println("Failed to borrow the third token.")
  28.     }
  30.     err := limit.Return()
  31.     if err != nil {
  32.         log.Println("Error returning token:", err)
  33.     } else {
  34.         fmt.Println("Successfully returned a token.")
  35.     }
  37.     err = limit.Return()
  38.     if err != nil {
  39.         log.Println("Error returning token:", err)
  40.     } else {
  41.         fmt.Println("Successfully returned a token.")
  42.     }
  43. }