定时器

/*
一次性的。
过期时，会通过 C 发送当前时间。
异步等待。
*/
type Timer struct {
    C <-chan Time
    // contains filtered or unexported fields
}

创建

// d 时间后触发
func NewTimer(d Duration) *Timer

/*
d 时间后触发，然后会在自己的协程中执行 f 。
*/
func AfterFunc(d Duration, f func()) *Timer

/*
d 时间后触发，通过通道发送当前时间。
等价于 NewTimer(d).C
*/
func After(d Duration) <-chan Time

/*
d 时间后触发，通过通道发送当前时间。
周期性的定时器。
*/
func Tick(d Duration) <-chan Time

package main

import (
	"fmt"
	"time"
)

var c chan int

func handle(int) {}

func main() {
	select {
	case m := <-c:
		handle(m)
	case <-time.After(1 * time.Second):
		fmt.Println("timed out")
	}
}

timed out

package main

import (
	"fmt"
	"time"
)

func main() {
	c := time.Tick(1 * time.Second)
	for now := range c {
		fmt.Printf("%v\n", now)
	}
}

2019-12-03 11:25:57.5281308 +0800 CST m=+1.004093001
2019-12-03 11:25:58.5408731 +0800 CST m=+2.016835301
2019-12-03 11:25:59.5420873 +0800 CST m=+3.018049501
exit status 2

重置

/*
将计时器更改为在 d 时间之后过期。
应该在已过期、或已停止的定时器上调用。
返回 true 表示定时器已**，返回 false 表示定时器已过期或已停止。
*/
func (t *Timer) Reset(d Duration) bool

停止

/*
返回 true 表示成功停止定时器，false 表示定时器已过期或已停止。
不会关闭通道。
为确保此调用之后通道为空，需要在返回 false 时读取通道：
if !t.Stop() {
	<-t.C
}
*/
func (t *Timer) Stop() bool

package main

import (
	"log"
	"time"
	"sync"
)

var mutex sync.Mutex
var stop = false
var quit chan struct{}

func myTimer() {
	timer := time.NewTimer(time.Second * 1)
	
	for {
		log.Println(<-timer.C)

		mutex.Lock()
		if stop {
			mutex.Unlock()
			break
		}
		mutex.Unlock()

		timer.Reset(time.Second * 1)
	}
	
	log.Println("exit")
	close(quit)
}

func main() {
	go myTimer()
	time.Sleep(time.Second * 3)

	mutex.Lock()
	stop = true
	mutex.Unlock()
	
	<-quit
}

2019/12/03 11:11:04 2019-12-03 11:11:04.1810824 +0800 CST m=+1.003007501
2019/12/03 11:11:05 2019-12-03 11:11:05.2057662 +0800 CST m=+2.027691301
2019/12/03 11:11:06 2019-12-03 11:11:06.2066059 +0800 CST m=+3.028531001
2019/12/03 11:11:06 exit