// New returns a Limiter that will limit to the given RPS.  func New(rate int, opts ...Option) Limiter {      return newAtomicBased(rate, opts...)  }    // newAtomicBased returns a new atomic based limiter.  func newAtomicBased(rate int, opts ...Option) *atomicLimiter {      // TODO consider moving config building to the implementation      // independent code.      config := buildConfig(opts)      perRequest := config.per / time.Duration(rate)      l := &atomicLimiter{          perRequest: perRequest,          maxSlack:   -1 * time.Duration(config.slack) * perRequest,          clock:      config.clock,      }        initialState := state{          last:     time.Time{},          sleepFor: 0,      }      atomic.StorePointer(&l.state, unsafe.Pointer(&initialState))      return l  }

 // Clock is the minimum necessary interface to instantiate a rate limiter with  // a clock or mock clock, compatible with clocks created using  // github.com/andres-erbsen/clock.  type Clock interface {     Now() time.Time     Sleep(time.Duration)  }

 type state struct {     last     time.Time     sleepFor time.Duration  }

 func (t *atomicLimiter) Take() time.Time {     var (        newState state        taken    bool        interval time.Duration     )     for !taken {        now := t.clock.Now()          previousStatePointer := atomic.LoadPointer(&t.state)        oldState := (*state)(previousStatePointer)          newState = state{           last:     now,           sleepFor: oldState.sleepFor,        }         if oldState.last.IsZero() {           taken = atomic.CompareAndSwapPointer(&t.state, previousStatePointer, unsafe.Pointer(&newState))           continue        }        // 計算是否需要進行等待取水操作        newState.sleepFor += t.perRequest(每兩滴水之間的間隔時間) - now.Sub(oldState.last)(當(dāng)前時間與上次取水時間的間隔)                  // 如果等待取水時間特別小，就需要松緊度進行維護        if newState.sleepFor < t.maxSlack {           newState.sleepFor = t.maxSlack        }         // 如果等待時間大于0，就進行更新        if newState.sleepFor > 0 {           newState.last = newState.last.Add(newState.sleepFor)           interval, newState.sleepFor = newState.sleepFor, 0        }        taken = atomic.CompareAndSwapPointer(&t.state, previousStatePointer, unsafe.Pointer(&newState))     }     t.clock.Sleep(interval)     // 最后返回需要等待的時間      return newState.last  }

 func (c *clock) Sleep(d time.Duration) { time.Sleep(d) }

 func ratelimit1() func(ctx *gin.Context) {      r1 := rate1.New(100)      return func(ctx *gin.Context) {          now := time.Now()          //  Take 返回的是一個 time.Duration的時間          if r1.Take().Sub(now) > 0 {              // 返回的時間比當(dāng)前的時間還大，說明需要進行等待              // 如果需要等待, 就 time.Sleep(r1.Take().Sub(now())) 然后放行              // 如果不需要等待請求時間，就直接進行Abort 然后返回              response(ctx, http.StatusRequestTimeout, "rate1 limit...")              fmt.Println("rate1 limit...")              ctx.Abort()              return          }          // 放行          ctx.Next()      }  }

 func response(c *gin.Context, code int, info any) {     c.JSON(code, info)  }    func pingHandler(c *gin.Context) {     response(c, 200, "ping ok~")  }

 func TestRun(t *testing.T) {     r := gin.Default()       r.GET("/ping1", ratelimit1(), pingHandler)     r.GET("/ping2", ratelimit2(), helloHandler)       _ = r.Run(":4399")  }

    Usage: go-wrk <options> <url>     Options:      -H       Header to add to each request (you can define multiple -H flags) (Default )      -M       HTTP method (Default GET)      -T       Socket/request timeout in ms (Default 1000)      -body    request body string or @filename (Default )      -c       Number of goroutines to use (concurrent connections) (Default 10)      -ca      CA file to verify peer against (SSL/TLS) (Default )      -cert    CA certificate file to verify peer against (SSL/TLS) (Default )      -d       Duration of test in seconds (Default 10)      -f       Playback file name (Default <empty>)      -help    Print help (Default false)      -host    Host Header (Default )      -http    Use HTTP/2 (Default true)      -key     Private key file name (SSL/TLS (Default )      -no-c    Disable Compression - Prevents sending the "Accept-Encoding: gzip" header (Default false)      -no-ka   Disable KeepAlive - prevents re-use of TCP connections between different HTTP requests (Default false)      -no-vr   Skip verifying SSL certificate of the server (Default false)      -redir   Allow Redirects (Default false)      -v       Print version details (Default false)

 // NewBucket returns a new token bucket that fills at the  // rate of one token every fillInterval, up to the given  // maximum capacity. Both arguments must be  // positive. The bucket is initially full.  func NewBucket(fillInterval time.Duration, capacity int64) *Bucket {     return NewBucketWithClock(fillInterval, capacity, nil)  }    // NewBucketWithClock is identical to NewBucket but injects a testable clock  // interface.  func NewBucketWithClock(fillInterval time.Duration, capacity int64, clock Clock) *Bucket {     return NewBucketWithQuantumAndClock(fillInterval, capacity, 1, clock)  }

 func NewBucketWithQuantumAndClock(fillInterval time.Duration, capacity, quantum int64, clock Clock) *Bucket {     if clock == nil {        clock = realClock{}     }      // 填充速率     if fillInterval <= 0 {        panic("token bucket fill interval is not > 0")     }      // 最大令牌容量     if capacity <= 0 {        panic("token bucket capacity is not > 0")     }      // 單次令牌生成量     if quantum <= 0 {        panic("token bucket quantum is not > 0")     }     return &Bucket{        clock:           clock,        startTime:       clock.Now(),        latestTick:      0,        fillInterval:    fillInterval,        capacity:        capacity,        quantum:         quantum,        availableTokens: capacity,     }  }

 // TakeAvailable takes up to count immediately available tokens from the  // bucket. It returns the number of tokens removed, or zero if there are  // no available tokens. It does not block.  func (tb *Bucket) TakeAvailable(count int64) int64 {     tb.mu.Lock()     defer tb.mu.Unlock()     return tb.takeAvailable(tb.clock.Now(), count)  }

 func (tb *Bucket) takeAvailable(now time.Time, count int64) int64 {     // 如果需要取出的令牌數(shù)小于等于零，那么就返回0個令牌      if count <= 0 {        return 0     }      // 根據(jù)時間對當(dāng)前桶中令牌數(shù)進行計算     tb.adjustavailableTokens(tb.currentTick(now))      // 計算之后的令牌總數(shù)小于等于0，說明當(dāng)前令牌不足取出，那么就直接返回0個令牌     if tb.availableTokens <= 0 {        return 0     }      // 如果當(dāng)前存儲的令牌數(shù)量多于請求數(shù)量，那么就返回取出令牌數(shù)     if count > tb.availableTokens {        count = tb.availableTokens     }      // 調(diào)整令牌數(shù)     tb.availableTokens -= count     return count  }

 func (tb *Bucket) adjustavailableTokens(tick int64) {     lastTick := tb.latestTick     tb.latestTick = tick      // 如果當(dāng)前令牌數(shù)大于最大等于容量，直接返回最大容量     if tb.availableTokens >= tb.capacity {        return     }      // 當(dāng)前令牌數(shù) += (當(dāng)前時間 - 上次取出令牌數(shù)的時間) * quannum(每次生成令牌量)     tb.availableTokens += (tick - lastTick) * tb.quantum      // 如果當(dāng)前令牌數(shù)大于最大等于容量, 將當(dāng)前令牌數(shù) = 最大容量 然后返回 當(dāng)前令牌數(shù)     if tb.availableTokens > tb.capacity {        tb.availableTokens = tb.capacity     }     return  }

 func ratelimit2() func(ctx *gin.Context) {      // 生成速率 最大容量      r2 := rate2.NewBucket(time.Second, 200)      return func(ctx *gin.Context) {          //r2.Take() // 允許欠賬，令牌不夠也可以接收請求          if r2.TakeAvailable(1) == 1 {              // 如果想要取出1個令牌并且能夠取出，就放行              ctx.Next()              return          }          response(ctx, http.StatusRequestTimeout, "rate2 limit...")          ctx.Abort()          return      }  }