主页 > 知识库 > 浅谈golang 中time.After释放的问题

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

热门标签:网站排名优化 AI电销 百度竞价排名 地方门户网站 呼叫中心市场需求 服务外包 铁路电话系统 Linux服务器

在谢大群里看到有同学在讨论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这个方法的超时就不起作用了。这里暂且保留着吧。

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

您可能感兴趣的文章:
  • Golang开发动态库的实现
  • golang实践-第三方包为私有库的配置方案
  • 完美解决golang go get私有仓库的问题
  • golang gopm get -g -v 无法获取第三方库的解决方案
  • Golang: 内建容器的用法
  • golang 定时任务方面time.Sleep和time.Tick的优劣对比分析
  • golang日志包logger的用法详解
  • Golang如何调用windows下的dll动态库中的函数

标签:崇左 铜川 湖南 湘潭 仙桃 衡水 黄山 兰州

巨人网络通讯声明:本文标题《浅谈golang 中time.After释放的问题》,本文关键词  ;如发现本文内容存在版权问题,烦请提供相关信息告之我们,我们将及时沟通与处理。本站内容系统采集于网络,涉及言论、版权与本站无关。
  • 相关文章
  • 收缩
    • 微信客服
    • 微信二维码
    • 电话咨询

    • 400-1100-266