Golang

关注公众号 jb51net

关闭
首页 > 脚本专栏 > Golang > Golang超时控制

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

作者:starrySky

本文将介绍为什么需要超时控制,然后详细介绍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. 适用场景分析

从上文可以看出,timetimerCtx都可以用于实现超时控制,但是事实上两者的适用场景其实是不太相同的。在某些场景下,超时控制并不适合使用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语言的实现也能够更好得进行融合在一起。

总结

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

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

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

5.总结

本文介绍了需要超时控制的原因,主要是避免无限期等待,防止资源泄漏和提高程序响应速度这几点内容。

接着我们介绍了Go语言中实现超时控制的方法,包括使用time实现超时控制以及使用context实现超时控制,并给出了简单的代码示例。

在接下来,我们便这两种实现的适用场景进行分析,明确了在哪些场景下,适合使用time实现超时控制,以及在哪些场景下,使用timerCtx来实现更为高效。

基于此,完成了为什么需要超时控制的介绍,希望能够让大家在遇到需要超时控制的场景下,更好得去进行实现。

以上就是深入了解Golang为什么需要超时控制的详细内容,更多关于Golang超时控制的资料请关注脚本之家其它相关文章!

您可能感兴趣的文章:
阅读全文