深入了解Golang为什么需要超时控制
作者:starrySky
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
来实现超时控制可能更加适合。
5.总结
本文介绍了需要超时控制的原因,主要是避免无限期等待,防止资源泄漏和提高程序响应速度这几点内容。
接着我们介绍了Go
语言中实现超时控制的方法,包括使用time
实现超时控制以及使用context
实现超时控制,并给出了简单的代码示例。
在接下来,我们便这两种实现的适用场景进行分析,明确了在哪些场景下,适合使用time
实现超时控制,以及在哪些场景下,使用timerCtx
来实现更为高效。
基于此,完成了为什么需要超时控制的介绍,希望能够让大家在遇到需要超时控制的场景下,更好得去进行实现。
以上就是深入了解Golang为什么需要超时控制的详细内容,更多关于Golang超时控制的资料请关注脚本之家其它相关文章!