Https://mmcgrana.github.io/2012/09/go-by-example-timers-and-tickers.html
--------------------------------------------------------------------------------------------------------------- -----------
Timers and Tickers
September 28 2012
If you ' re interested on go, be sure to check out Go by Example.
We often want to execute Go code at some point in the future, or repeatedly at some interval. Go ' s built-in timer and ticker features make both of these tasks easy. Let's look at the some examples to see how the They work.
Timers
Timers represent a single event on the future. You tell the timer how long you want to wait, and it gives you a channel that'll be notified at that time. For example, to wait 2 seconds:
package mainimport " Time "func main () {timer := time. Newtimer (time. Second * 2) <-timer c println ( "Timer Expired" ) Span class= "P" >
The <- timer.C
blocks on the timer's channel C
until it sends a value indicating that the timer expired. You can test the putting of the code in and timers1.go
running it with time
and go run
:
$ time go run timers1.goTimer expiredreal 0m2.113s
If you just wanted to wait, you could has used time.Sleep
. One reason a timer may be useful is so you can cancel the timer before it expires. For example, try running this in timers2.go
:
PackageMainImport"Time"FuncMain(){timer := time. Newtimer (time. Second) go func () { <-timer. C println ( "Timer Expired" ) } () Span class= "NX" >stop := timer. Stop () println ( "Timer cancelled:" , stop) }
$ go run timers2.goTimer cancelled: true
In this case we canceled the timer before it had a chance to expire ( Stop()
would return false if we tried to cancel it aft ER it expired.)
Tickers
Timers is for-when-you-want-do something once in the future-tickers is for-when-you-want-do something repeatedly At regular intervals. Here ' s a basic example:
PackageMainImport"Time"Import"FMT"FuncMain(){Ticker:=Time.Newticker(Time.Millisecond*500)GoFunc(){ForT:= range ticker. C {fmt. Println ( "Tick at" t) } } () time. Sleep (time. Millisecond * 1500) ticker.< Span class= "NX" >stop () fmt. Println ( "Ticker stopped" ) }
Try it out in tickers.go
:
$ go run tickers.goTick at 2012-09-22 15:58:40.912926 -0400 EDTTick at 2012-09-22 15:58:41.413892 -0400 EDTTick at 2012-09-22 15:58:41.913888 -0400 EDTTicker stopped
Tickers can stopped just like timers using Stop()
the method, as shown at the bottom of the example.
Power of Channels
A great feature of Go ' s timers and tickers are that they hooks into Go ' built-in concurrency mechanism:channels. This allows timers and tickers to interact seamlessly with other concurrent goroutines. For example:
PackageMainImport"Time"Import"FMT"FuncMain(){Timechan:=Time.Newtimer(Time.Second).CTickchan:=Time.Newticker(Time.Millisecond*400).CDonechan:=Make(Chanbool)GoFunc(){Time.Sleep(Time.Second*2)Donechan<-True}()For{select {case <-timeChan: fmt. Println ( "Timer Expired" ) case <-tickchan: fmt. Println ( "Ticker ticked" ) case donechan: fmt. Println ( "done" ) return } }} /span>
Try it out by running the This Code form channels.go
:
$ go run channels.goTicker tickedTicker tickedTimer expiredTicker tickedTicker tickedTicker tickedDone
In the "we see" the timer, ticker, and our own custom goroutine all participating in the same select
block. The combination of the Go runtime, its channel feature, and timers/tickers use of channels make this kind of cooperation V Ery Natural in Go.
You can learn more on timers, tickers, and other time-related go features in the Go Package time
docs.
Timer and ticker timer tasks in the Go language