淺談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的說明:

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這個方法的超時就不起作用瞭。這裡暫且保留著吧。

以上為個人經驗,希望能給大傢一個參考,也希望大傢多多支持WalkonNet。如有錯誤或未考慮完全的地方,望不吝賜教。