您当前所在位置：首页 > 脚本专栏 > Golang

Golang

深进了解Golang为什么需要超时控制

[db:来源] 2023-05-08Golang682

本文将介绍为什么需要超时控制，然后具体介绍Go语言中实现超时控制的方法，文中的示例代码讲解具体，感爱好的小伙伴可以跟随小编一起了解一下

1. 简介

本文将介绍为什么需要超时控制，然后具体介绍Go语言中实现超时控制的方法。其中，我们将讨论time包和context包实现超时控制的详细方式，并说明两者的适用场景，以便在程序中以更合适的方式来实现超时控制，提高程序的稳定性和可靠性。

2. 为什么需要超时控制

超时控制是指在入行网络哀求或者协程执行等操作时，为了避免程序一直等待，造成资源浪费，我们需要对这些操作设置一个超时时间，在规定时间内未完成操作，就需要停止等待或者终止操作。

例如，在入行网络哀求时，假如服务器端出现问题导致没有及时响应，客户端可能会一直等待服务器的响应，这样会造成客户端资源的浪费。

举个简朴的例子，比如我们需要从遥程服务器获取某个资源，我们可以使用以下代码来入行实现：

func getResource() (Resource, error) {
    conn, err := net.Dial("tcp", "example.com:8888")
    if err != nil {
        return nil, err
    }
    defer conn.Close()
    // 发送哀求并等待响应
    _, err = conn.Write([]byte("GET /resource HTTP/1.1\r\nHost: example.com\r\n\r\n"))
    if err != nil {
        return nil, err
    }
    resp, err := ioutil.ReadAll(conn)
    if err != nil {
        return nil, err
    }
    // 解析响应并返归资源
    return parseResource(resp)
}

但是假如遥程服务器在我们发送哀求后一直没有响应，那么我们的程序就会一直等待，无法继承执行其他任务。

在某些情况下，这可能会导致程序的阻塞，从而影响程序的性能和稳定性。因此，在入行网络通信等操作时，尤其是在调用外部API或者访问遥程服务器时，一定要使用超时控制。那么，在Go语言中，超时控制的实现方式有哪些呢？

3. 超时控制的方法

3.1 time包实现超时控制

time包提供了多种方式来实现超时控制，包括time.After函数、time.NewTimer函数以及time.AfterFunc函数，使用它们可以实现超时控制，下面以time.NewTimer函数为例，说明如何使用其time包实现超时控制。代码示例如下:

// 创建一个定时器
timer := time.NewTimer(5 * time.Second)
defer timer.Stop()

// 使用一个channel来监听任务是否已完成
ch := make(chan string, 1)     
go func() {         
// 模仿任务执行，休眠5秒         
    time.Sleep(2* time.Second)         
    ch <- "hello world"     
}()

// 通过select语句来等待结果,任务正常返归
select {
case <-ch:
    fmt.Println("任务正常完成")
  // ch 已经接收到值，走正常处理逻辑
case <-timer.C:
    fmt.Println("已超时")
  // 超时，走超时逻辑
}

在这里例子中，我们使用 time.NewTimer 方法创建一个定时器，超时时间为2秒钟。然后在 select 语句中使用来等待结果，哪个先返归就使用哪个。

假如操作在2秒钟内完成，那么任务正常完成；假如操作超过2秒钟仍未完成，此时select语句中<-timer.C将接收到值，走超时处理逻辑。

3.2 context实现超时控制

Context 接口是 Go 语言标准库中提供的一个上下文（Context）治理机制。它答应在程序的不同部分之间传递上下文信息，并且可以通过它实现超时控制、取消操作以及截断操作等功能。其中，Context接口存在一个timerCtx的实现，其可以设定一个超时时间，在到达超时时间后，timerCtx对象的 done channel 将会被关闭。

当需要判定是否超时时，只需要调用 context 对象的 Done 方法，其会返归timerCtx对象中的done channel，假如有数据返归，则说明已经超时。基于此，我们便可以实现超时控制。代码示例如下:

// 创建一个timerCtx，设置超时时间为3秒     
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)     
// 调用cancel函数,释放占用的资源  
defer cancel()
// 使用一个channel来监听任务是否已完成
ch := make(chan string, 1)     
go func() {         
// 模仿任务执行，休眠5秒         
    time.Sleep(2* time.Second)         
    ch <- "hello world"     
}()
// 通过select语句来等待结果,任务正常返归
select {
    case <-ctx.Done():
        fmt.Println("timeout")
    case result := <-ch:
        fmt.Println(result)
}

这里通过context.WithTimeout创建一个timerCtx，设定好超时时间，超时时间为3s。然后启动一个协程来执行详细的业务逻辑。

之后通过select语句，对timerCtx和业务执行结果同时入行监听，当任务处理超时时，则执行超时逻辑；假如任务在超时前完成，则执行正常处理流程。通过这种方式，实现了哀求的超时处理。

4. 适用场景分析

从上文可以观出，time和 timerCtx都可以用于实现超时控制，但是事实上两者的适用场景其实是不太相同的。在某些场景下,超时控制并不适合使用time来实现，而是使用timerCtx来实现更为合适。而在某些场景下，其实两种实现方式均可。

下面我简朴介绍几种常见的场景，然后对其来入行分析，从而能够在合适的场景下使用恰当得实现。

4.1 简朴超时控制

举个例子，假设我们需要从一个遥程服务获取一些数据，我们可以使用Go标准库中的http包入行网络哀求，大概哀求函数如下:

func makeRequest(url string) (string, error) {
   // 哀求数据
}

此时为了避免哀求响应时间过长，导致程序长时间处于等待状态，此时我们需要对这个函数实现超时处理，确保程序能够及时响应其他哀求，而不是一直等待。

为了实现这个目的，此时可以使用time包或者timerCtx来实现超时控制。在makeRequest函数中实现超时控制，这里代码铺示与第三点超时控制的方法中的代码示例大体相同，只需要将协程中sleep函数切换成详细的业务逻辑即可，这里不再赘述。而且，查观上面代码示例，我们也可以观出来timer或者timerCtx在这个场景下，区别并不大，此时是可以相互替换的。

因此，对于这种控制某个函数的执行时间的场景，是可以任意挑选time或者timerCtx其中一个来实现的。

4.2 可选超时控制

这里我们实现一个方法，用于建立网络连接，用户调用该方法时，传进待建立连接的地址列表，然后该方法通过遍历传进的地址列表，并针对每一个地址入行连接尝试，直到连接成功或者所有地址都尝试完成。函数定义如下:

func dialSerial(ras addrList) (Conn, error){
   // 执行建立网络连接的逻辑
}

基于此，在这个函数的基础上，实现一个可选的超时控制的功能。假如用户调用该方法时，有指定超时时间的话，此时便入行超时控制；假如未指定超时时间的话，此时便无需执行超时控制。这里分别使用time包以及context实现。

首先对于time包实现可选的超时控制，可以通过函数参数传递定时器来实现可选的超时控制。详细地说，可以将定时器作为一个time.Timer类型的参数传递给函数，然后在函数中使用select监听time.Timer是超时；假如没有传递定时器实例，则默认不入行超时控制，代码实现如下所示:

func dialSerial(timeout time.Timer, ras addrList) (Conn, error){
   // 执行建立网络连接的逻辑，对每个地址尝试建立连接时，先检查是否超时
   for i, ra := range ras {
          // 通过这里来入行超时控制,首先先判定是否传进定时器实例
          if timeout != nil {
              select {
              // 监听是否超时
              case <-timeout.C:
                  return nil, errors.New("timeout")
              default:
              }
          }
         // 执行后续建立网络连接的逻辑          
   }
}

接着则是使用timerCtx来实现超时控制的实现，可以通过函数传递一个context.Context接口的参数来实现超时控制。

详细来说，用户可以传递一个context.Context接口的实现，假如有指定超时时间，则传进一个timerCtx的实现；假如无需超时控制，此时可以传进context.Background，其永遥不会超时。然后函数中通过调用Done方法来判定是否超时，从而实现超时控制。代码实现如下:

func dialSerial(ctx context.Context, ras addrList) (Conn, error){
   // 执行建立网络连接的逻辑，对每个地址尝试建立连接时，先检查是否超时
   for i, ra := range ras {
       select {
       case <-ctx.Done():
          return nil, &OpError{Op: "dial", Net: sd.network, Source: sd.LocalAddr, Addr: ra, Err: mapErr(ctx.Err())}
       default: 
       }
       // 执行建立网络连接的逻辑
   }
}

查观上述代码中，dialSerial函数实现可选超时控制，观起来只是传进参数不同，一个是传进定时器time.Timer实例，一个是传进context.Context接口实例而已，但是实际上不仅仅如此。

首先是代码的可读性上来观，传进time.Timer实例来实现超时控制，并非Go中常见的实现方式，用户不好理解；而对于context.Context接口来说，其被广泛使用，假如要实现超时控制，用户只需要传进一个timerCtx实例即可，用户使用起来没有额外的心智负担，代码可读性更强。

其次是对于整个Go语言的生态来说，context.Context接口在Go语言标准库中得到广泛使用，而且普遍超时控制都是使用timerCtx来实现的，假如此时传进一个time.Timer实例，实际上是与整个Go语言的超时控制的格格不进的。以上面dialSerial方法为例，其建立网络连接是需要调用底层函数来协助实现的，如:

func (fd *netFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (rsa syscall.Sockaddr, ret error) {
    // 执行建立连接的逻辑
    switch err := connectFunc(fd.pfd.Sysfd, ra); err {
    // 未报错,此时检查是否超时
    case nil, syscall.EISCONN:
       select {
       case <-ctx.Done():
           // 假如已经超时,此时返归超时错误
          return nil, mapErr(ctx.Err())
       default:
       }
     }
}

而且刚好，该函数也是实现了可选的超时控制，而且是通过timerCtx来实现的，假如此时传进的timerCtx已经超时，此时函数会直接返归一个超时错误。

假如上面dialSerial的超时控制是通过context.Context的接口实例来实现的话，此时调用函数时，直接将外部的Context实例作为参数传进connect函数，外层调用也无需再检查函数是否超时，代码的可复用性更高。

相对的，假如dialSerial的超时控制是通过传进定时器实现的，此时便无法很好利用connect方法已经实现的超时检查的机制。

因此，综上所述，使用 context.Context 接口作为可选的超时控制参数，相比于使用 time.Timer，更加适合同时也更加高效，与整个Go语言的实现也能够更好得入行融合在一起。

总结

Context 和 Time 都是 Go 语言中实现超时控制的方法，它们各有优缺点，不能说哪一种实现更好，要根据详细的场景来选择使用哪种方法。

在一些简朴的场景下，使用 Time 包实现超时控制可能更加方便，因为它的 API 更加简朴，只需要使用 time.After() 函数即可实现超时控制。

但是，假如涉及到在多个函数，或者是需要多个goroutine之间传递的话，此时使用Context来实现超时控制可能更加适合。