快捷導(dǎo)航

淺談golang 中time.After釋放的問題

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

這篇文章主要介紹了淺談golang 中time.After釋放的問題，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧

在謝大群里看到有同學(xué)在討論time.After泄漏的問題，就算時間到了也不會釋放，瞬間就驚呆了，忍不住做了試驗(yàn)，結(jié)果發(fā)現(xiàn)應(yīng)該沒有這么的恐怖的，是有泄漏的風(fēng)險不過不算是泄漏，

先看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)
    }
}

顯示內(nèi)存穩(wěn)定在5.3MB，CPU為161%，肯定被GC回收了的。

當(dāng)然如果放在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)
}

只是資源消耗會多一點(diǎn)，CPU為422%，內(nèi)存占用6.4MB。因此：

Remark: time.After(d)在d時間之后就會fire，然后被GC回收，不會造成資源泄漏的。

那么API所說的If efficieny is a concern, user NewTimer instead and call Timer.Stop是什么意思呢？這是因?yàn)橐话鉻ime.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:
        }
    }
}

這個時候，就相當(dāng)于會堆積了3秒的timer沒有釋放而已，會不斷的新建和釋放timer，內(nèi)存會穩(wěn)定在2.8GB，

這個當(dāng)然就不是最好的了，可以主動釋放：

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

這樣就不會占用2.8GB內(nèi)存了，只有5MB左右。因此，總結(jié)下這個After的說明：

1、GC肯定會回收time.After的，就在d之后就回收。一般情況下讓系統(tǒng)自己回收就好了。

2、如果有效率問題，應(yīng)該使用Timer在不需要時主動Stop。大部分時候都不用考慮這個問題的。

交作業(yè)。

補(bǔ)充：go語言基于time.After通道超時設(shè)計(jì)和通道關(guān)閉close

go語言中多個并發(fā)程序的數(shù)據(jù)同步是采用通道來傳輸，比如v:=<-chan，從通道里讀取數(shù)據(jù)到v，是一個阻塞操作?？墒侨缤ǖ览餂]有數(shù)據(jù)寫入，就是chan<-data，這樣寫入通道的操作，在讀操作時就會一直阻塞，需要加入一個超時機(jī)制來進(jìn)行判斷。

具體的超時設(shè)計(jì)是通過使用select和case語句，類似于switch和case，在每一個case里進(jìn)行一個io操作，比如讀或者寫，在最后一個case里調(diào)用time包里的After方法，可以達(dá)到超時檢測效果。參考下面例子1

當(dāng)然，如寫入端在寫入通道結(jié)束后，調(diào)用close(chan)關(guān)閉通道。在讀取端，就會讀到一個該通道類型的空值，如是int就是0，如是string就是""空字符串，可以根據(jù)這個空值來判斷，或者使用兩個返回值來讀取通道：v,br:=<-chan，這里第2個參數(shù)br是一個bool變量，表示通道是否關(guān)閉。參考下面例子2

例子1如下：

package main 
import (
	"fmt"
	"time"
)
 
func main() {
	ch := make(chan string, 2)//定義了緩沖長度2的通道，類型是字符串，可以連續(xù)寫入2次數(shù)據(jù)
	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 //定義超時次數(shù)
	for {
		time.Sleep(time.Millisecond * 2000) //每隔2秒讀取下管道
		select {
		case i := <-ch:
			fmt.Println("通道讀取到:", i)
		case <-time.After(time.Second * 2): // 等待2秒超時，這里time.After 返回一個只讀通道，就是當(dāng)前時間值
			timelate++
			fmt.Printf("通道接收超時,第%d次\n", timelate)
			if timelate > 2 {
				goto end
			}
		}
	}
end:
	fmt.Println("退出88")
}

例子2如下：

演示了close關(guān)閉通道，使用2個返回值來讀取通道，獲取通道關(guān)閉狀態(tài)。

package main 
import (
	"fmt"
	"time"
)
 
func main() {
	ch := make(chan string, 2) //定義了緩沖長度2的通道，類型是字符串，可以連續(xù)寫入2次數(shù)據(jù)
	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) //專門給這個協(xié)程加個1秒的延時，讓它晚退出會，好調(diào)用close關(guān)閉通道。
		close(c)
	}(ch)
	timelate := 0 //定義超時次數(shù)
	for {
		time.Sleep(time.Millisecond * 2000) //每隔2秒讀取下管道
		select {
		case i, br := <-ch: //從通道里讀取2個返回值，第2個是通道是否關(guān)閉的bool變量
			if !br { //如果是false，表示通道關(guān)閉
				fmt.Println("通道關(guān)閉了")
				goto end
			}
			fmt.Println("通道讀取到:", i)
		case <-time.After(time.Second * 2): // 等待2秒超時，這里time.After 返回一個只讀通道，就是當(dāng)前時間值
			timelate++
			fmt.Printf("通道接收超時,第%d次\n", timelate)
			if timelate > 2 {
				goto end
			}
		}
	}
end:
	fmt.Println("退出88")
}