浅谈golang 中time.After释放的问题

更新时间：2021年05月04日 11:45:12 作者：win_lin

这篇文章主要介绍了浅谈golang 中time.After释放的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

在谢大群里看到有同学在讨论time.After泄漏的问题，就算时间到了也不会释放，瞬间就惊呆了，忍不住做了试验，结果发现应该没有这么的恐怖的，是有泄漏的风险不过不算是泄漏，

先看API的说明：

// After waits for the duration to elapse and then sends the current time
// on the returned channel.
// It is equivalent to NewTimer(d).C.
// The underlying Timer is not recovered by the garbage collector
// until the timer fires. If efficiency is a concern, use NewTimer
// instead and call Timer.Stop if the timer is no longer needed.
func After(d Duration) <-chan Time {
    return NewTimer(d).C
}

提到了一句The underlying Timer is not recovered by the garbage collector，这句挺吓人不会被GC回收，不过后面还有条件until the timer fires，说明fire后是会被回收的，所谓fire就是到时间了，

写个例子证明下压压惊：

package main
import "time"
func main() {
    for {
        <- time.After(10 * time.Nanosecond)
    }
}

显示内存稳定在5.3MB，CPU为161%，肯定被GC回收了的。

当然如果放在goroutine也是没有问题的，一样会回收：

package main
import "time"
func main() {
    for i := 0; i < 100; i++ {
        go func(){
            for {
                <- time.After(10 * time.Nanosecond)
            }
        }()
    }
    time.Sleep(1 * time.Hour)
}

只是资源消耗会多一点，CPU为422%，内存占用6.4MB。因此：

Remark: time.After(d)在d时间之后就会fire，然后被GC回收，不会造成资源泄漏的。

那么API所说的If efficieny is a concern, user NewTimer instead and call Timer.Stop是什么意思呢？这是因为一般time.After会在select中使用，如果另外的分支跑得更快，那么timer是不会立马释放的(到期后才会释放)，

比如这种：

select {
    case time.After(3*time.Second):
        return errTimeout
    case packet := packetChannel:
        // process packet.
}

如果packet非常多，那么总是会走到下面的分支，上面的timer不会立刻释放而是在3秒后才能释放，

和下面代码一样：

package main
import "time"
func main() {
    for {
        select {
        case <-time.After(3 * time.Second):
        default:
        }
    }
}

这个时候，就相当于会堆积了3秒的timer没有释放而已，会不断的新建和释放timer，内存会稳定在2.8GB，

这个当然就不是最好的了，可以主动释放：

package main
import "time"
func main() {
    for {
        t := time.NewTimer(3*time.Second)
        select {
        case <- t.C:
        default:
            t.Stop()
        }
    }
}

这样就不会占用2.8GB内存了，只有5MB左右。因此，总结下这个After的说明：

1、GC肯定会回收time.After的，就在d之后就回收。一般情况下让系统自己回收就好了。

2、如果有效率问题，应该使用Timer在不需要时主动Stop。大部分时候都不用考虑这个问题的。

交作业。

补充：go语言基于time.After通道超时设计和通道关闭close

go语言中多个并发程序的数据同步是采用通道来传输，比如v:=<-chan，从通道里读取数据到v，是一个阻塞操作。可是如通道里没有数据写入，就是chan<-data，这样写入通道的操作，在读操作时就会一直阻塞，需要加入一个超时机制来进行判断。

具体的超时设计是通过使用select和case语句，类似于switch和case，在每一个case里进行一个io操作，比如读或者写，在最后一个case里调用time包里的After方法，可以达到超时检测效果。参考下面例子1

当然，如写入端在写入通道结束后，调用close(chan)关闭通道。在读取端，就会读到一个该通道类型的空值，如是int就是0，如是string就是""空字符串，可以根据这个空值来判断，或者使用两个返回值来读取通道：v,br:=<-chan，这里第2个参数br是一个bool变量，表示通道是否关闭。参考下面例子2

例子1如下：

package main 
import (
	"fmt"
	"time"
)
 
func main() {
	ch := make(chan string, 2)//定义了缓冲长度2的通道，类型是字符串，可以连续写入2次数据
	go func(c chan string) {
		for i := 0; i < 3; i++ {
			str := fmt.Sprintf("%d", i)
			c <- str
			time.Sleep(time.Millisecond * 10)
		}
	}(ch)
	go func(c chan string) {
		for i := 10; i < 13; i++ {
			str := fmt.Sprintf("%d", i)
			c <- str
			time.Sleep(time.Millisecond * 10)
		}
	}(ch)
	timelate := 0 //定义超时次数
	for {
		time.Sleep(time.Millisecond * 2000) //每隔2秒读取下管道
		select {
		case i := <-ch:
			fmt.Println("通道读取到:", i)
		case <-time.After(time.Second * 2): // 等待2秒超时，这里time.After 返回一个只读通道，就是当前时间值
			timelate++
			fmt.Printf("通道接收超时,第%d次\n", timelate)
			if timelate > 2 {
				goto end
			}
		}
	}
end:
	fmt.Println("退出88")
}

例子2如下：

演示了close关闭通道，使用2个返回值来读取通道，获取通道关闭状态。

package main 
import (
	"fmt"
	"time"
)
 
func main() {
	ch := make(chan string, 2) //定义了缓冲长度2的通道，类型是字符串，可以连续写入2次数据
	go func(c chan string) {
		for i := 0; i < 3; i++ {
			str := fmt.Sprintf("%d", i)
			c <- str
			time.Sleep(time.Millisecond * 10)
		}
	}(ch)
	go func(c chan string) {
		for i := 10; i < 13; i++ {
			str := fmt.Sprintf("%d", i)
			c <- str
			time.Sleep(time.Millisecond * 10)
		}
		time.Sleep(time.Millisecond * 1000) //专门给这个协程加个1秒的延时，让它晚退出会，好调用close关闭通道。
		close(c)
	}(ch)
	timelate := 0 //定义超时次数
	for {
		time.Sleep(time.Millisecond * 2000) //每隔2秒读取下管道
		select {
		case i, br := <-ch: //从通道里读取2个返回值，第2个是通道是否关闭的bool变量
			if !br { //如果是false，表示通道关闭
				fmt.Println("通道关闭了")
				goto end
			}
			fmt.Println("通道读取到:", i)
		case <-time.After(time.Second * 2): // 等待2秒超时，这里time.After 返回一个只读通道，就是当前时间值
			timelate++
			fmt.Printf("通道接收超时,第%d次\n", timelate)
			if timelate > 2 {
				goto end
			}
		}
	}
end:
	fmt.Println("退出88")
}

对于例子2来说，这里因为在通道写入端用close关闭通道了，所以case <-time.After这个方法的超时就不起作用了。这里暂且保留着吧。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。如有错误或未考虑完全的地方，望不吝赐教。

您可能感兴趣的文章:

使用Go构建一款静态分析工具Owl详解
Owl是一款开源项目依赖分析工具，可以快速在指定的项目目录下查找符合某些特征的源代码文件或者依赖文件，这篇文章主要介绍了使用Go构建一款静态分析工具,需要的朋友可以参考下
2022-06-06
深入了解Golang中的格式化输出
fmt是Go语言中用于控制文本输出的常用标准库，文中将通过示例详细讲解一下Go语言中不同形式的格式化输出，感兴趣的小伙伴可以了解一下
2022-11-11
试了下Golang实现try catch的方法
虽然在使用Golang的时候发现没有try catch这种错误处理机制但是想一想golang作为一门优雅的语言，似乎也是情理之中。那么够怎么捕获异常呢，本文就来介绍一下
2021-07-07
Golang编程实现生成n个从a到b不重复随机数的方法
这篇文章主要介绍了Golang编程实现生成n个从a到b不重复随机数的方法,结合实例形式分析了Go语言字符串操作及随机数生成的相关操作技巧,需要的朋友可以参考下
2017-01-01
详解如何在Golang中实现CORS(跨域)
很多时候,需要允许Web应用程序在不同域之间（跨域）实现共享资源,本文将简介跨域、CORS的概念,以及如何在Golang中如何实现CORS,文中有详细的示例代码,需要的朋友可以参考下
2023-10-10
Go项目在GoLand中导入依赖标红问题的解决方案
这篇文章主要介绍了Go项目在GoLand中导入依赖标红问题的解决方案,文中通过代码示例讲解的非常详细,对大家的学习或工作有一定的帮助,需要的朋友可以参考下
2024-06-06
golang sql连接池的实现方法详解
database/sql是golang的标准库之一，它提供了一系列接口方法，用于访问关系数据库。下面这篇文章主要给大家介绍了关于golang sql连接池用法的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面来一起看看吧
2018-09-09
Go语言中io包核心接口示例详解
Go的io包提供了io.Reader和io.Writer接口,分别用于数据的输入和输出,下面这篇文章主要给大家介绍了关于Go语言中io包核心接口的相关资料,需要的朋友可以参考下
2021-12-12
一文带你全面掌握Go语言中的正则表达式
正则表达式是一种强大的模式匹配工具，能够在文本中进行灵活的搜索和替换操作，本文将介绍 Golang 中的正则表达式语法，包括常用的匹配符号、模式修饰符以及示例应用，希望对大家有所帮助
2023-05-05
使用IDEA配置GO语言的开发环境备忘录
最近在配置idea开发go语言时碰到很多问题,想着很多人都可能会遇到,所以下面这篇文章主要给大家介绍了关于使用IDEA配置GO语言的开发环境,文中通过图文介绍的非常详细,需要的朋友可以参考下
2024-05-05