詳解Go語言的計時器

時間  2020-05-20
標籤 詳解 語言 計時器 简体版
原文   原文鏈接

Go語言的標準庫裏提供兩種類型的計時器Timer和Ticker。Timer通過指定的duration時間後被觸發，往本身的時間channel發送當前時間，此後Timer再也不計時。Ticker則是每隔duration時間都會把當前時間點發送給本身的時間channel，利用計時器的時間channel能夠實現不少與計時相關的功能。git

文章主要涉及以下內容：github

  • Timer和Ticker計時器的內部結構表示
  • Timer和Ticker的使用方法和注意事項
  • 如何正確Reset定時器

計時器的內部表示

兩種計時器都是基於Go語言的運行時計時器runtime.timer實現的，rumtime.timer的結構體表示以下：golang

type timer struct {
	pp puintptr

	when     int64
	period   int64
	f        func(interface{}, uintptr) arg interface{}
	seq      uintptr
	nextwhen int64
	status   uint32
}
複製代碼

rumtime.timer結構體中的字段含義是shell

  • when — 當前計時器被喚醒的時間；
  • period — 兩次被喚醒的間隔；
  • f — 每當計時器被喚醒時都會調用的函數；
  • arg — 計時器被喚醒時調用 f 傳入的參數；
  • nextWhen — 計時器處於 timerModifiedLater/timerModifiedEairlier 狀態時，用於設置 when 字段；
  • status — 計時器的狀態；

這裏的 runtime.timer 只是私有的計時器運行時表示，對外暴露的計時器 time.Timer 和time.Ticker的結構體表示以下：緩存

type Timer struct {
	C <-chan Time
	r runtimeTimer
}

type Ticker struct {
	C <-chan Time 
	r runtimeTimer
}
複製代碼

Timer.C和Ticker.C就是計時器中的時間channel，接下來咱們看一下怎麼使用這兩種計時器，以及使用時要注意的地方。bash

Timer計時器

time.Timer 計時器必須經過 time.NewTimer、time.AfterFunc 或者 time.After 函數建立。 當計時器失效時，失效的時間就會被髮送給計時器持有的 channel，訂閱 channel 的 goroutine 會收到計時器失效的時間。函數

經過定時器Timer用戶能夠定義本身的超時邏輯，尤爲是在應對使用select處理多個channel的超時、單channel讀寫的超時等情形時尤其方便。Timer常見的使用方法以下：oop

//使用time.AfterFunc：

t := time.AfterFunc(d, f)

//使用time.After：
select {
    case m := <-c:
       handle(m)
    case <-time.After(5 * time.Minute):
       fmt.Println("timed out")
}

// 使用time.NewTimer:
t := time.NewTimer(5 * time.Minute)
select {
    case m := <-c:
       handle(m)
    case <-t.C:
       fmt.Println("timed out")
}
複製代碼

time.AfterFunc這種方式建立的Timer，在到達超時時間後會在單獨的goroutine裏執行函數f。ui

func AfterFunc(d Duration, f func()) *Timer {
	t := &Timer{
		r: runtimeTimer{
			when: when(d),
			f:    goFunc,
			arg:  f,
		},
	}
	startTimer(&t.r)
	return t
}

func goFunc(arg interface{}, seq uintptr) {
	go arg.(func())() } 複製代碼

從上面AfterFunc的源碼能夠看到外面傳入的f參數並不是直接賦值給了運行時計時器的f，而是做爲包裝函數goFunc的參數傳入的。goFunc會啓動了一個新的goroutine來執行外部傳入的函數f。這是由於全部計時器的事件函數都是由Go運行時內惟一的goroutine timerproc運行的。爲了避免阻塞timerproc的執行，必須啓動一個新的goroutine執行到期的事件函數。spa

對於NewTimer和After這兩種建立方法，則是Timer在超時後，執行一個標準庫中內置的函數：sendTime。

func NewTimer(d Duration) *Timer {
	c := make(chan Time, 1)
	t := &Timer{
		C: c,
		r: runtimeTimer{
			when: when(d),
			f:    sendTime,
			arg:  c,
		},
	}
	startTimer(&t.r)
	return t
}

func sendTime(c interface{}, seq uintptr) {
	select {
	case c.(chan Time) <- Now():
	default:
	}
}
複製代碼

sendTime將當前時間發送到Timer的時間channel中。那麼這個動做不會阻塞timerproc的執行麼？答案是不會，緣由是NewTimer建立的是一個帶緩衝的channel因此不管Timer.C這個channel有沒有接收方sendTime均可以非阻塞的將當前時間發送給Timer.C，並且sendTime中還加了雙保險：經過select判斷Timer.C的Buffer是否已滿，一旦滿了，會直接退出，依然不會阻塞。

Timer的Stop方法能夠阻止計時器觸發，調用Stop方法成功中止了計時器的觸發將會返回true，若是計時器已通過期了或者已經被Stop中止過了，再次調用Stop方法將會返回false。

Go運行時將全部計時器維護在一個最小堆Min Heap中，Stop一個計時器就是從堆中刪除該計時器。

Ticker計時器

Ticker能夠週期性地觸發時間事件，每次到達指定的時間間隔後都會觸發事件。

time.Ticker須要經過time.NewTicker或者time.Tick建立。

// 使用time.Tick:
go func() {
	for t := range time.Tick(time.Minute) {
		fmt.Println("Tick at", t)
	}
}()

// 使用time.Ticker
var ticker *time.Ticker = time.NewTicker(1 * time.Second)

go func() {
    for t := range ticker.C {
        fmt.Println("Tick at", t)
    }
}()

time.Sleep(time.Second * 5)
ticker.Stop()     
fmt.Println("Ticker stopped")
複製代碼

不過time.Tick不多會被用到，除非你想在程序的整個生命週期裏都使用time.Ticker的時間channel。官文文檔裏對time.Tick的描述是：

time.Tick底層的Ticker不能被垃圾收集器恢復；

因此使用time.Tick時必定要當心，爲避免意外儘可能使用time.NewTicker返回的Ticker替代。

NewTicker建立的計時器與NewTimer建立的計時器持有的時間channel同樣都是帶一個緩存的channel，每次觸發後執行的函數也是sendTime，這樣即保證了不管有誤接收方Ticker觸發時間事件時都不會阻塞：

func NewTicker(d Duration) *Ticker {
	if d <= 0 {
		panic(errors.New("non-positive interval for NewTicker"))
	}
	// Give the channel a 1-element time buffer.
	// If the client falls behind while reading, we drop ticks
	// on the floor until the client catches up.
	c := make(chan Time, 1)
	t := &Ticker{
		C: c,
		r: runtimeTimer{
			when:   when(d),
			period: int64(d),
			f:      sendTime,
			arg:    c,
		},
	}
	startTimer(&t.r)
	return t
}
複製代碼

Reset計時器時要注意的問題

關於Reset的使用建議，文檔裏的描述是：

重置計時器時必須注意不要與當前計時器到期發送時間到t.C的操做產生競爭。若是程序已經從t.C接收到值，則計時器是已知的已過時，而且t.Reset能夠直接使用。若是程序還沒有從t.C接收值，計時器必須先被中止，而且-若是使用t.Stop時報告計時器已過時，那麼請排空其通道中值。

例如：

if !t.Stop() {
  <-t.C
}
t.Reset(d)
複製代碼

下面的例子裏producer goroutine裏每一秒向通道中發送一個false值，循環結束後等待一秒再往通道里發送一個true值。在consumer goroutine裏經過循環試圖從通道中讀取值，用計時器設置了最長等待時間爲5秒，若是計時器超時了，輸出當前時間並進行下次循環嘗試，若是從通道中讀取出的不是期待的值（預期值是true)，則嘗試從新從通道中讀取並重置計時器。

func main() {
    c := make(chan bool)

    go func() {
        for i := 0; i < 5; i++ {
            time.Sleep(time.Second * 1)
            c <- false
        }

        time.Sleep(time.Second * 1)
        c <- true
    }()

    go func() {
        // try to read from channel, block at most 5s.
        // if timeout, print time event and go on loop.
        // if read a message which is not the type we want(we want true, not false),
        // retry to read.
        timer := time.NewTimer(time.Second * 5)
        for {
            // timer is active , not fired, stop always returns true, no problems occurs.
            if !timer.Stop() {
                <-timer.C
            }
            timer.Reset(time.Second * 5)
            select {
            case b := <-c:
                if b == false {
                    fmt.Println(time.Now(), ":recv false. continue")
                    continue
                }
                //we want true, not false
                fmt.Println(time.Now(), ":recv true. return")
                return
            case <-timer.C:
                fmt.Println(time.Now(), ":timer expired")
                continue
            }
        }
    }()

    //to avoid that all goroutine blocks.
    var s string
    fmt.Scanln(&s)
}
複製代碼

程序的輸出以下：

2020-05-13 12:49:48.90292 +0800 CST m=+1.004554120 :recv false. continue
2020-05-13 12:49:49.906087 +0800 CST m=+2.007748042 :recv false. continue
2020-05-13 12:49:50.910208 +0800 CST m=+3.011892138 :recv false. continue
2020-05-13 12:49:51.914291 +0800 CST m=+4.015997373 :recv false. continue
2020-05-13 12:49:52.916762 +0800 CST m=+5.018489240 :recv false. continue
2020-05-13 12:49:53.920384 +0800 CST m=+6.022129708 :recv true. return
複製代碼

目前來看沒什麼問題，使用Reset重置計時器也起做用了，接下來咱們對producer goroutin作一些更改，咱們把producer goroutine裏每秒發送值的邏輯改爲每6秒發送值，而consumer gouroutine裏和計時器仍是5秒就到期。

// producer
	go func() {
		for i := 0; i < 5; i++ {
			time.Sleep(time.Second * 6)
			c <- false
		}

		time.Sleep(time.Second * 6)
		c <- true
	}()
複製代碼

再次運行會發現程序發生了deadlock在第一次報告計時器過時後直接阻塞住了：

2020-05-13 13:09:11.166976 +0800 CST m=+5.005266022 :timer expired


複製代碼

那程序是在哪阻塞住的呢？對就是在抽乾timer.C通道時阻塞住了（英文叫作drain channel比喻成流乾管道里的水，在程序裏就是讓timer.C管道中再也不存在未接收的值)。

if !timer.Stop() {
    <-timer.C
}
timer.Reset(time.Second * 5)
複製代碼

producer goroutine的發送行爲發生了變化，comsumer goroutine在收到第一個數據前有了一次計時器過時的事件，for循環進行一下次循環。這時timer.Stop函數返回的再也不是true，而是false，由於計時器已通過期了，上面提到的維護着全部活躍計時器的最小堆中已經不包含該計時器了。而此時timer.C中並無數據，接下來用於drain channel的代碼會將consumer goroutine阻塞住。

這種狀況，咱們應該直接Reset計時器，而不用顯式drain channel。如何將這兩種情形合二爲一呢？咱們能夠利用一個select來包裹drain channel的操做，這樣不管channel中是否有數據，drain都不會阻塞住。

//consumer
    go func() {
        // try to read from channel, block at most 5s.
        // if timeout, print time event and go on loop.
        // if read a message which is not the type we want(we want true, not false),
        // retry to read.
        timer := time.NewTimer(time.Second * 5)
        for {
            // timer may be not active, and fired
            if !timer.Stop() {
                select {
                case <-timer.C: //try to drain from the channel
                default:
                }
            }
            timer.Reset(time.Second * 5)
            select {
            case b := <-c:
                if b == false {
                    fmt.Println(time.Now(), ":recv false. continue")
                    continue
                }
                //we want true, not false
                fmt.Println(time.Now(), ":recv true. return")
                return
            case <-timer.C:
                fmt.Println(time.Now(), ":timer expired")
                continue
            }
        }
    }()
複製代碼

運行修改後的程序，發現程序不會被阻塞住，能正常進行通道讀取，讀取到true值後會自行退出。輸出結果以下：

2020-05-13 13:25:08.412679 +0800 CST m=+5.005475546 :timer expired
2020-05-13 13:25:09.409249 +0800 CST m=+6.002037341 :recv false. continue
2020-05-13 13:25:14.412282 +0800 CST m=+11.005029547 :timer expired
2020-05-13 13:25:15.414482 +0800 CST m=+12.007221569 :recv false. continue
2020-05-13 13:25:20.416826 +0800 CST m=+17.009524859 :timer expired
2020-05-13 13:25:21.418555 +0800 CST m=+18.011245687 :recv false. continue
2020-05-13 13:25:26.42388 +0800 CST m=+23.016530193 :timer expired
2020-05-13 13:25:27.42294 +0800 CST m=+24.015582511 :recv false. continue
2020-05-13 13:25:32.425666 +0800 CST m=+29.018267054 :timer expired
2020-05-13 13:25:33.428189 +0800 CST m=+30.020782483 :recv false. continue
2020-05-13 13:25:38.432428 +0800 CST m=+35.024980796 :timer expired
2020-05-13 13:25:39.428343 +0800 CST m=+36.020887629 :recv true. return

複製代碼

總結

以上比較詳細地介紹了Go語言的計時器以及它們的使用方法和注意事項，總結一下有以下關鍵點：

  • Timer和Ticker都是在運行時計時器runtime.timer的基礎上實現的。
  • 運行時裏的全部計時器的事件函數都由運行時內惟一的goroutine timerproc觸發。
  • time.Tick建立的Ticker在運行時不會被gc回收，能不用就不用。
  • Timer和Ticker的時間channel都是帶有一個緩衝的通道。
  • time.After，time.NewTimer，time.NewTicker建立的計時器觸發時都會執行sendTime。
  • sendTime和計時器帶緩存的時間通道保證了計時器不會阻塞程序。
  • Reset計時器時要注意drain channel和計時器過時存在競爭條件。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程