Detailed explanation of how to implement Go timeout control

                                                                                                                     

The following tutorial column will introduce to you how to implement Go timeout control. I hope it will be helpful to friends in need!

Why do we need timeout control?

The request time is too long, the user may have left this page, the server is still consuming resources for processing, and the results obtained are meaningless

The server-side processing will take too long Occupying too many resources, resulting in reduced concurrency and even unavailability accidents

• Go Necessity of timeout control

Go is normally used to write the backend For service, generally a request is completed by multiple serial or parallel subtasks. Each subtask may be another internal request. Then when the request times out, we need to return quickly and release the occupied resources. Such as goroutine, file descriptor, etc.

Common timeout control on the server side

Logical processing within the process

Reading and writing clients Side requests, such as HTTP or RPC requests

• Call other server-side requests, including calling RPC or accessing DB, etc.
• What will happen if there is no timeout control?

To simplify this article, we take a request function hardWork as an example. It doesn’t matter what it is used for. As the name suggests, it may be slower to process.

func hardWork(job interface{}) error {
    time.Sleep(time.Minute)
    return nil}func requestWork(ctx context.Context, job interface{}) error {
  return hardWork(job)}

At this time, what the client sees is always the familiar picture

The vast majority of users will not look at chrysanthemums for a minute and give up early If you leave, you will be left with a bunch of resource occupation on the entire call link. This article will not go into other details and only focus on the timeout implementation.

Let’s take a look at how to implement timeout and what pitfalls there will be.

First version implementation

You can stop reading and try to think about how to implement the timeout of this function. First try:

func requestWork(ctx context.Context, job interface{}) error {
    ctx, cancel := context.WithTimeout(ctx, time.Second*2)
    defer cancel()

    done := make(chan error)
    go func() {
        done 

Let’s write a main function to test it

func main() {
    const total = 1000
    var wg sync.WaitGroup
    wg.Add(total)
    now := time.Now()
    for i := 0; i <p>Run it to see the effect</p><pre class="brush:php;toolbar:false">➜ go run timeout.go
elapsed: 2.005725931s

The timeout has taken effect. But is this done?

goroutine leakage

Let us add a line of code at the end of the main function to see how many goroutines have been executed

time.Sleep(time.Minute*2)fmt.Println("number of goroutines:", runtime.NumGoroutine())

sleep 2 minutes is to wait for all The task ends, and then we print the current number of goroutines. Let's execute it and see the result

➜ go run timeout.go
elapsed: 2.005725931s
number of goroutines: 1001

goroutine is leaked, let's see why this happens? First of all, the

requestWork

function exits after 2 seconds timeout. Once the

requestWork

function exits, then done channel will have no goroutine to receive it. Wait until executiondone This line of code will be stuck and cannot be written, causing each timeout request to occupy a goroutine. This is a big bug. When the resources are exhausted, When the time comes, the entire service becomes unresponsive. <code>So how to fix it? In fact, it is very simple. Just set buffer size to 1 when

make chan

, as follows: <pre class="brush:php;toolbar:false">done := make(chan error, 1)</pre>This way, done Can write without blocking the goroutine regardless of whether it times out. At this point, someone may ask if there will be any problem if you write to a channel that has no goroutine to receive it. In Go, the channel is not like our common file descriptors. It does not have to be closed, it is just an object.

close(channel)

is only used to tell the receiver that there is nothing to write, and has no other purpose. After changing this line of code, let’s test it again: <pre class="brush:php;toolbar:false">➜ go run timeout.go elapsed: 2.005655146s number of goroutines: 1</pre>The goroutine leak problem is solved!

panic cannot be caught

Let us change the hardWork function implementation to

panic("oops")

Modifymain The function plus the code for catching exceptions is as follows:

go func() {
  defer func() {
    if p := recover(); p != nil {
      fmt.Println("oops, panic")
    }
  }()

  defer wg.Done()
  requestWork(context.Background(), "any")}()

If you execute it at this time, you will find that panic cannot be captured. The reason is that other panics generated in the goroutine inside requestWork goroutine cannot catch.

The solution is to add panicChan to

requestWork

for processing. Similarly, the buffer size of panicChan is required to be 1 ,as follows:<pre class="brush:php;toolbar:false">func requestWork(ctx context.Context, job interface{}) error {     ctx, cancel := context.WithTimeout(ctx, time.Second*2)     defer cancel()     done := make(chan error, 1)     panicChan := make(chan interface{}, 1)     go func() {         defer func() {             if p := recover(); p != nil {                 panicChan &lt;p&gt;改完就可以在 &lt;code&gt;requestWork&lt;/code&gt; 的调用方处理 &lt;code&gt;panic&lt;/code&gt; 了。&lt;/p&gt;&lt;h2&gt; &lt;span class=&quot;header-link octicon octicon-link&quot;&gt;&lt;/span&gt;超时时长一定对吗？&lt;/h2&gt;&lt;p&gt;上面的 &lt;code&gt;requestWork&lt;/code&gt; 实现忽略了传入的 &lt;code&gt;ctx&lt;/code&gt; 参数，如果 &lt;code&gt;ctx&lt;/code&gt; 已有超时设置，我们一定要关注此传入的超时是不是小于这里给的2秒，如果小于，就需要用传入的超时，&lt;code&gt;go-zero/core/contextx&lt;/code&gt; 已经提供了方法帮我们一行代码搞定，只需修改如下：&lt;/p&gt;&lt;pre class=&quot;brush:php;toolbar:false&quot;&gt;ctx, cancel := contextx.ShrinkDeadline(ctx, time.Second*2)</pre><h2> <span class="header-link octicon octicon-link"></span>Data race</h2><p>这里 <code>requestWork 只是返回了一个 error 参数，如果需要返回多个参数，那么我们就需要注意 data race，此时可以通过锁来解决，具体实现参考 go-zero/zrpc/internal/serverinterceptors/timeoutinterceptor.go，这里不做赘述。

完整示例

package mainimport (
    "context"
    "fmt"
    "runtime"
    "sync"
    "time"

    "github.com/tal-tech/go-zero/core/contextx")func hardWork(job interface{}) error {
    time.Sleep(time.Second * 10)
    return nil}func requestWork(ctx context.Context, job interface{}) error {
    ctx, cancel := contextx.ShrinkDeadline(ctx, time.Second*2)
    defer cancel()

    done := make(chan error, 1)
    panicChan := make(chan interface{}, 1)
    go func() {
        defer func() {
            if p := recover(); p != nil {
                panicChan <h2>
<span class="header-link octicon octicon-link"></span>更多细节</h2><p>请参考 <code>go-zero</code> 源码：</p>

• go-zero/core/fx/timeout.go
• go-zero/zrpc/internal/clientinterceptors/timeoutinterceptor.go
• go-zero/zrpc/internal/serverinterceptors/timeoutinterceptor.go

项目地址

github.com/tal-tech/go-zero

欢迎使用 go-zero 并 star 支持我们！

The above is the detailed content of Detailed explanation of how to implement Go timeout control. For more information, please follow other related articles on the PHP Chinese website!