Golang中的time.After的使用理解
關于在goroutine中使用time.After的理解， 新手在學習過程中的“此時此刻”的理解，錯誤還請指正。
先線上代碼：
package main
import (
"fmt"
"time"
)
func main() {
//closeChannel()
c := make(chan int)
timeout := time.After(time.Second * 2) //
t1 := time.NewTimer(time.Second * 3) // 效果相同 只執行一次
var i int
go func() {
for {
select {
case -c:
fmt.Println("channel sign")
return
case -t1.C: // 代碼段2
fmt.Println("3s定時任務")
case -timeout: // 代碼段1
i++
fmt.Println(i, "2s定時輸出")
case -time.After(time.Second * 4): // 代碼段3
fmt.Println("4s timeout。。。。")
default: // 代碼段4
fmt.Println("default")
time.Sleep(time.Second * 1)
}
}
}()
time.Sleep(time.Second * 6)
close(c)
time.Sleep(time.Second * 2)
fmt.Println("main退出")
}
主要有以上4點是我們平時遇到的。
首先遇到的問題是：
如上的代碼情況下， 代碼段3處的case 永遠不執行， 無論main進程執行多久。這是為什么呢？
首先我們分析為啥不執行代碼段3， 而是程序一直執行的是default. 由此我們判斷：
case - time.After(time.Second) :
是本次監聽動作的超時時間， 意思就說，只有在本次select 操作中會有效， 再次select 又會重新開始計時（從當前時間+4秒后）， 但是有default ，那case 超時操作，肯定執行不到了。
那么問題就簡單了我們預先定義了計時操作：
case - timeout:
在goroutine開始前， 我們記錄了時間，在此時間3s之后進行操作。相當于定時任務， 并且只執行一次。 代碼段1和代碼段2 實現的結果都相同
針對以上問題解決后，我寫了一個小案例：
package main
import (
"fmt"
"time"
)
//發送者
func sender(c chan int) {
for i := 0; i 100; i++ {
c - i
if i >= 5 {
time.Sleep(time.Second * 7)
} else {
time.Sleep(time.Second)
}
}
}
func main() {
c := make(chan int)
go sender(c)
timeout := time.After(time.Second * 3)
for {
select {
case d := -c:
fmt.Println(d)
case -timeout:
fmt.Println("這是定時操作任務 >>>>>")
case dd := -time.After(time.Second * 3):
fmt.Println(dd, "這是超時*****")
}
fmt.Println("for end")
}
}
執行結果：
要注意的是，雖然執行到i == 6時， 堵塞了，并且執行了超時操作， 但是下次select 依舊去除的是6
因為通道中已經發送了6,如果未取出，程序堵塞。
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的說明：
- GC肯定會回收time.After的，就在d之后就回收。一般情況下讓系統自己回收就好了。
- 如果有效率問題，應該使用Timer在不需要時主動Stop。大部分時候都不用考慮這個問題的。
總結
以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，如果有疑問大家可以留言交流，謝謝大家對腳本之家的支持。
您可能感興趣的文章:- Go語言利用time.After實現超時控制的方法詳解
