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

本篇文章给大家分享《浅谈golang 中time.After释放的问题》，覆盖了Golang的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

在谢大群里看到有同学在讨论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) 

<p>提到了一句The underlying Timer is not recovered by the garbage collector，这句挺吓人不会被GC回收，不过后面还有条件until the timer fires，说明fire后是会被回收的，所谓fire就是到时间了，</p>
<h2>写个例子证明下压压惊：</h2>

<pre class="brush:plain;">
package main
import "time"
func main() {
    for {
        

<p>显示内存稳定在5.3MB，CPU为161%，肯定被GC回收了的。</p>
<h2>当然如果放在goroutine也是没有问题的，一样会回收：</h2>

<pre class="brush:plain;">
package main
import "time"
func main() {
    for i := 0; i 

<p>只是资源消耗会多一点，CPU为422%，内存占用6.4MB。因此：</p>
<p>Remark: time.After(d)在d时间之后就会fire，然后被GC回收，不会造成资源泄漏的。</p>
<p>那么API所说的If efficieny is a concern, user NewTimer instead and call Timer.Stop是什么意思呢？这是因为一般time.After会在select中使用，如果另外的分支跑得更快，那么timer是不会立马释放的(到期后才会释放)，</p>
<h2>比如这种：</h2>

<pre class="brush:plain;">
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 

<p>这个时候，就相当于会堆积了3秒的timer没有释放而已，会不断的新建和释放timer，内存会稳定在2.8GB，</p>
<h2>这个当然就不是最好的了，可以主动释放：</h2>

<pre class="brush:plain;">
package main
import "time"
func main() {
    for {
        t := time.NewTimer(3*time.Second)
        select {
        case 

<p>这样就不会占用2.8GB内存了，只有5MB左右。因此，总结下这个After的说明：</p>
<p>1、GC肯定会回收time.After的，就在d之后就回收。一般情况下让系统自己回收就好了。</p>
<p>2、如果有效率问题，应该使用Timer在不需要时主动Stop。大部分时候都不用考虑这个问题的。</p>
<p>交作业。</p>
<p><strong>补充：go语言基于time.After通道超时设计和通道关闭close</strong></p>
<p>go语言中多个并发程序的数据同步是采用通道来传输，比如v:=
</p><p>具体的超时设计是通过使用select和case语句，类似于switch和case，在每一个case里进行一个io操作，比如读或者写，在最后一个case里调用time包里的After方法，可以达到超时检测效果。参考下面例子1</p>
<p>当然，如写入端在写入通道结束后，调用close(chan)关闭通道。在读取端，就会读到一个该通道类型的空值，如是int就是0，如是string就是""空字符串，可以根据这个空值来判断，或者使用两个返回值来读取通道：v,br:=
</p><h2>例子1如下：</h2>

<pre class="brush:plain;">
package main 
import (
	"fmt"
	"time"
)
 
func main() {
	ch := make(chan string, 2)//定义了缓冲长度2的通道，类型是字符串，可以连续写入2次数据
	go func(c chan string) {
		for i := 0; i  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  2 {
				goto end
			}
		}
	}
end:
	fmt.Println("退出88")
}

对于例子2来说，这里因为在通道写入端用close关闭通道了，所以case

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

今天带大家了解了time.After、释放的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~