在谢大群里看到有同学在讨论time.after泄漏的问题，就算时间到了也不会释放，瞬间就惊呆了，忍不住做了试验，结果发现应该没有这么的恐怖的，是有泄漏的风险不过不算是泄漏，
先看api的说明：|
1
2
3
4
5
6
7
8
9
|
// 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就是到时间了，
写个例子证明下压压惊：|
1
2
3
4
5
6
7
|
package main
import "time"
func main() {
for {
<- time.after(10 * time.nanosecond)
}
}
|
显示内存稳定在5.3mb，cpu为161%，肯定被gc回收了的。
当然如果放在goroutine也是没有问题的，一样会回收：|
1
2
3
4
5
6
7
8
9
10
11
12
|
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是不会立马释放的(到期后才会释放)，
比如这种：|
1
2
3
4
5
6
|
select {
case time.after(3*time.second):
return errtimeout
case packet := packetchannel:
// process packet.
}
|
如果packet非常多，那么总是会走到下面的分支，上面的timer不会立刻释放而是在3秒后才能释放，
和下面代码一样：|
1
2
3
4
5
6
7
8
9
10
|
package main
import "time"
func main() {
for {
select {
case <-time.after(3 * time.second):
default:
}
}
}
|
这个时候，就相当于会堆积了3秒的timer没有释放而已，会不断的新建和释放timer，内存会稳定在2.8gb，
这个当然就不是最好的了，可以主动释放：|
1
2
3
4
5
6
7
8
9
10
11
12
|
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如下：|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
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")
}
|
演示了close关闭通道，使用2个返回值来读取通道，获取通道关闭状态。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
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这个方法的超时就不起作用了。这里暂且保留着吧。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。如有错误或未考虑完全的地方，望不吝赐教。
原文链接：https://winlin.blog.csdn.net/article/details/76302153