Golang timer implements current limiting

In daily development, we often face high-concurrency scenarios, and strict current limiting is particularly important at this time. In Golang, a common way to implement current limiting is to use a timer (Timer) to limit the number of concurrent requests by controlling the trigger time of the timer. This article will introduce how to use Golang's timer to implement current limiting.

1. What is a timer?

In Golang, Timer is a system-level timer. You can create a timer to trigger tasks or events regularly. When creating a Timer, you need to specify a time interval, and you can use the Reset method to reset or stop the timer.

The basic idea of ​​using a timer to implement current limiting is: set a time interval, such as 1 second. Whenever a request arrives, we reset the timer. If the number of requests arriving within 1 second If the set threshold is exceeded, the requests will be rejected.

2. The process of using timers to implement current limiting

The process of using timers to implement current limiting is as follows:

1. Initialize the counter and timer.
2. Whenever a request is received, increase the counter value and reset the timer.
3. When the time interval arrives, determine whether the counter value exceeds the limit value. If it does, reject the request. Otherwise, clear the counter and wait for the next request.

3. Implementation Code Example

In Golang, the time package in the standard library provides Timer type and Ticker type, which can be used to create timers. The following is a sample code that uses Timer to implement current limiting:

package main

import (
    "fmt"
    "time"
)

func main() {
    maxRequests := 100 //最多请求量
    interval := 1 * time.Second //间隔时间
    timer := time.NewTimer(interval)
    counter := 0 //请求计数器

    for {
        select {
        case <-timer.C: // 定时器到期
            fmt.Println("time up")
            if counter > maxRequests { // 如果请求数超出限制
                fmt.Printf("too many requests, counter=%d
", counter)
            } else {
                fmt.Printf("counter=%d
", counter)
            }
            counter = 0 // 重置计数器
            timer.Reset(interval) // 重置定时器
        default:
            time.Sleep(time.Millisecond * 100) // 模拟处理请求的耗时
            counter++ // 计数器加1
        }
    }
}

Code analysis:

This sample code sets a current limiting controller with a maximum number of requests of 100 and an interval of 1 second. . In the main loop, monitor the expiration event of the timer through the select statement, and perform current limiting processing when the timer expires.

Use time.Sleep in the default branch to simulate the consumption time of the request and add 1 to the counter. When the timer expires, determine whether the counter value exceeds the set threshold. If it does, reject the request and output a prompt message indicating that there are too many requests. Otherwise, output the current number of requests, clear the counter, and reset the timer. .

4. Use Ticker to implement current limiting

In addition to Timer, Golang also provides a time type called Ticker, which is similar to the Timer type, but can trigger events periodically. The following is a code example that also uses counters and timers to implement current limiting. This time the Ticker type is used:

package main

import (
    "fmt"
    "time"
)

func main() {
    maxRequests := 100 //最多请求量
    interval := 1 * time.Second //间隔时间
    ticker := time.NewTicker(interval)
    counter := 0 //请求计数器

    for {
        select {
        case <-ticker.C: // 定时器到期
            fmt.Println("time up")
            if counter > maxRequests { // 如果请求数超出限制
                fmt.Printf("too many requests, counter=%d
", counter)
            } else {
                fmt.Printf("counter=%d
", counter)
            }
            counter = 0 // 重置计数器
        default:
            time.Sleep(time.Millisecond * 100) // 模拟处理请求的耗时
            counter++ // 计数器加1
        }
    }
}

The difference from the example code implemented by Timer is that this time we use the NewTicker function to create Timer object and listen to the timer's tick event in the main loop. When the tick event arrives, the counter is checked and cleared, the processing time of the request is simulated in the default branch, and the counter value is incremented.

It should be noted that when using Ticker, the Stop method must be called to stop the timer when the program exits. Otherwise, the timer will always run in the background and waste resources.

5. Summary

This article introduces how to use Golang’s timer (Timer) and Ticker to implement current limiting. In high-concurrency scenarios, strict current limiting control is crucial. of. Using timers to implement current limiting is an efficient and reliable way, and is an indispensable component for many enterprise-level web applications.

During the implementation process, you need to understand the working principle and usage of the timer, and reasonably set parameters such as time interval and maximum number of requests to ensure that the current limiting control can achieve the optimal effect.

The above is the detailed content of Golang timer implements current limiting. For more information, please follow other related articles on the PHP Chinese website!