How to implement request limits using context in Go

How to use context to implement request limits in Go

When developing web applications, request limits are a very important task, which can help us control the use of resources and protect the stability of the system. The context package is provided in the standard library of Go language, which can be used to manage request context and implement request restriction functions. This article will introduce how to use context to implement request restrictions in Go and give corresponding code examples.

1. Understand the context package

The context package is a standard library in the Go language used to transfer request context information. It provides some methods to help us manage the life cycle of requests, cancel requests, pass request values, etc. The following are some commonly used methods in the context package:

1. context.Background(): Create an empty Context, usually used as the root node of the Context tree.
2. context.WithCancel(parent): Create a Context with cancellation function to cancel the execution of the child Context.
3. context.WithDeadline(parent,deadline): Create a Context with a deadline function to cancel the execution of the child Context before the specified time.
4. context.WithTimeout(parent,timeout): Create a Context with a timeout function to cancel the execution of the child Context after the specified time.
5. context.WithValue(parent,key,value): Create a Context with value transfer function for transferring values ​​in the Context tree.

2. Use context to implement request restriction

Below we will use some methods of the context package to implement a simple request restriction function. Suppose we want to limit a certain interface to only handle 10 requests per second. Requests exceeding this limit will be rejected. We can achieve this function by using the context package. The code is as follows:

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // 创建一个带有取消功能的Context
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    // 启动一个goroutine来执行请求处理
    go handleRequests(ctx)

    // 模拟发送100个请求
    for i := 1; i <= 100; i++ {
        select {
        case <-ctx.Done():
            fmt.Println("Too many requests, request", i, "cancelled")
        default:
            // 发送请求
            sendRequest(i)

            // 等待一秒钟
            time.Sleep(time.Second)
        }
    }
}

func handleRequests(ctx context.Context) {
    // 创建一个计数器
    counter := 0

    for {
        select {
        case <-ctx.Done():
            return
        default:
            // 检查当前请求数量是否超过限制
            if counter >= 10 {
                time.Sleep(time.Second)
            } else {
                // 处理请求
                handleRequest(counter)

                // 计数器加一
                counter++
            }
        }
    }
}

func handleRequest(requestID int) {
    fmt.Println("Handling request", requestID)
}

func sendRequest(requestID int) {
    fmt.Println("Sending request", requestID)
}

In the above code, we first create a Context with cancellation function and start a goroutine to handle the request. Then, in the loop that simulates sending requests, we use the select statement to determine whether the current number of requests exceeds the limit. If it does not exceed the limit, then send the request and increase the counter by one, otherwise wait for one second. Finally, in the function that handles the request, we simply print out the request ID.

3. Running results

When we run the above code, the output result will be similar to the following:

Sending request 1
Handling request 0
Sending request 2
Handling request 1
Sending request 3
Handling request 2
Sending request 4
Handling request 3
Sending request 5
Handling request 4
Sending request 6
Handling request 5
Sending request 7
Handling request 6
Sending request 8
Handling request 7
Sending request 9
Handling request 8
Too many requests, request 11 cancelled
Too many requests, request 16 cancelled
Too many requests, request 21 cancelled
...

As can be seen from the output result, the first 10 requests It can be processed normally, but as time goes by, the number of requests sent exceeds the limit, so the requests that exceed the limit are cancelled.

4. Summary

This article introduces how to use the context package to implement request restriction. Through code examples, we learned how to create, cancel, and pass contexts, and how to limit the number of requests while using contexts. I hope that through the introduction of this article, you can better understand how to use context to implement request restrictions in Go.

The above is the detailed content of How to implement request limits using context in Go. For more information, please follow other related articles on the PHP Chinese website!