import “time”
定时器
type Ticker struct {
C <-chan Time // 周期性传递时间信息的通道
r runtimeTimer
}
Ticker保管一个通道,并每隔一段时间向其传递"tick"。
func NewTicker(d Duration) *Ticker
NewTicker返回一个新的Ticker,该Ticker包含一个通道字段,并会每隔时间段d就向该通道发送当时的时间。它会调整时间间隔或者丢弃tick信息以适应反应慢的接收者。如果d<=0会panic。关闭该Ticker可以释放相关资源。
func (t *Ticker) Stop()
Stop关闭一个Ticker。在关闭后,将不会发送更多的tick信息。Stop不会关闭通道t.C,以避免从该通道的读取不正确的成功。
func Sleep(d Duration)
Sleep阻塞当前go程至少d代表的时间段。d<=0时,Sleep会立刻返回。
func After(d Duration) <-chan Time
After会在另一线程经过时间段d后向返回值发送当时的时间。等价于NewTimer(d).C。
func Tick(d Duration) <-chan Time
Tick是NewTicker的封装,只提供对Ticker的通道的访问。如果不需要关闭Ticker,本函数就很方便。
定时器实现
package main
import (
"fmt"
"time"
)
func main() {
timer1 := time.NewTicker(1 * time.Second)
for {
select {
case <-timer1.C:
fmt.Println("每隔1秒打印一次")
}
}
}
package main
import (
"fmt"
"time"
)
func main() {
waittime := make(chan time.Time, 3)
for i := 0; i < 3; i++ {
waittime <- time.Now() // 向通道 waittime 发送三次
}
go func() {
for t := range time.Tick(time.Second * 2) {
waittime <- t // 每隔2秒向通道 waittime 发送一次值
}
}()
burstyRequests := make(chan int, 5)
for i := 1; i <= 5; i++ {
burstyRequests <- i
<-waittime //前三个打印没有时间限制,会直接打印出后面的println的内容
fmt.Println("request", i, time.Now())
}
close(burstyRequests)
for req := range burstyRequests {
<-waittime //接收waittime值,除了前三次,后面的都是2秒打印一次,直到循环5次结束
fmt.Println("request", req, time.Now())
}
}
运行结果
request 1 2018-12-21 14:10:22 +0800 CST m=+0.010000001
request 2 2018-12-21 14:10:22.05 +0800 CST m=+0.060000001
request 3 2018-12-21 14:10:22.051 +0800 CST m=+0.061000001
request 4 2018-12-21 14:10:24 +0800 CST m=+2.010000001
request 5 2018-12-21 14:10:26 +0800 CST m=+4.010000001
request 1 2018-12-21 14:10:28 +0800 CST m=+6.010000001
request 2 2018-12-21 14:10:30 +0800 CST m=+8.010000001
request 3 2018-12-21 14:10:32 +0800 CST m=+10.010000001
request 4 2018-12-21 14:10:34 +0800 CST m=+12.010000001
request 5 2018-12-21 14:10:36.015 +0800 CST m=+14.025000001