ticker

通过 time.NewTicker() 创建，这种类型 ticker 会不断的按照设定的间隔时间触发，除非主动终止运行。

  1. ticker := time.NewTicker(time.Second * 1) // 运行时长
  3. for range ticker.C {
  4.     fmt.Printf("ticker")
  5. }
  1. ticker := time.NewTicker(time.Second * 1) // 运行时长
  2.     ch := make(chan int)
  3.     go func() {
  4.         var x int
  5.         for x < 10 {
  6.             select {
  7.             case <-ticker.C:
  8.                 x++
  9.                 fmt.Printf("%d\n", x)
  10.             }
  11.         }
  12.         ticker.Stop()
  13.         ch <- 0
  14.     }()
  15.     <-ch                                    // 通过通道阻塞，让任务可以执行完指定的次数。

timer

通过 time.NewTimer() 创建，这种类型，timer只会执行一次，当然，可以在执行完以后通过用 timer.Reset() 让定时器再次工作，并可以更改时间间隔。

  1. tt := time.NewTimer(time.Second * 10)
  2. <-tt.C
  1. timer := time.NewTimer(time.Second * 1) // timer 只能按时触发一次，可通过Reset()重置后继续触发。
  2.     go func() {
  3.         var x int
  4.         for {
  5.             select {
  6.             case <-timer.C:
  7.                 x++
  8.                 fmt.Printf("%d,%s\n", x, time.Now().Format("2006-01-02 15:04:05"))
  9.                 if x < 10 {
  10.                     timer.Reset(time.Second * 2)
  11.                 } else {
  12.                     ch <- x
  13.                 }
  14.             }
  15.         }
  16.     }()
  17.     <-ch

After

After()其实是timer的一个语法糖。

  1. // 同步
  2. <-time.After(time.Second * 4)
  4. // 异步
  5. time.AfterFunc(time.Second, func() {
  6.     fmt.Println("timer exit")
  7. })