When developing servers, there are times when you need to limit the frequency of certain actions.
For instance, you may want to limit the number of requests to prevent overloading due to an external attack on internal servers or when calling an external service API.
One commonly used method in such cases is using time.Sleep().
For example, if an API needs to be called repeatedly at a 1-second interval, the code could look like this:
for {
// ...
someAPICall()
time.Sleep(1 * time.Second)
// ...
}
However, this method always causes a 1-second wait, which means it takes 1 second to call the API even when there is no congestion.
Using the rate Package
A more sophisticated method is using the rate package from golang.org/x/time.
The x package is an official library by Go but includes experimental packages with loose compatibility requirements, developed differently from the Go core.
For example, context.Context, which is now an official package, was in x before being added in Go 1.7.
The rate package is intended for implementing a Rate Limiter and primarily uses the token bucket algorithm.
The token bucket algorithm operates by generating tokens at a steady rate and depleting tokens as requests come in. For instance, if the token generation rate is 2 per second and the bucket capacity is 30, the first 30 tokens are used quickly, but once full, only 2 tokens per second are used.
Seeing is believing! First, import the x package
import "golang.org/x/time/rate"
Then, create a Rate Limiter using rate.NewLimiter().
var limiter = rate.NewLimiter(2, 1)
It can be declared as a global variable or within a function; however, if used within a function, especially in cases like servers, it should be maintained as a singleton instance via injection to function correctly.
I declared it as a global variable for convenience in the example above.
Then, call limiter.Wait() before the place you want to restrict.
var limiter = rate.NewLimiter(1, 5)
func main() {
ctx := context.Background()
for range 10 {
if err := limiter.Wait(ctx); err != nil {
log.Fatal(err)
}
slog.InfoContext(ctx, "Requesting...")
}
}
The result is as follows:
2025/04/02 16:19:44 INFO Requesting...
2025/04/02 16:19:44 INFO Requesting...
2025/04/02 16:19:44 INFO Requesting...
2025/04/02 16:19:44 INFO Requesting...
2025/04/02 16:19:44 INFO Requesting...
2025/04/02 16:19:45 INFO Requesting...
2025/04/02 16:19:46 INFO Requesting...
2025/04/02 16:19:47 INFO Requesting...
2025/04/02 16:19:48 INFO Requesting...
2025/04/02 16:19:49 INFO Requesting...
Upon checking the logs, you can see that the first 5 requests are consumed quickly due to the bucket’s capacity (5 tokens), and the following 5 requests are consumed gradually at a rate of 1 per second.