一起学Go之计时器（Timer/Tick）

最新推荐文章于 2023-05-04 11:11:54 发布
最新推荐文章于 2023-05-04 11:11:54 发布
阅读量3.1k 收藏 6
点赞数
分类专栏： 一起学go 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lin_keys/article/details/120608940
版权

前言

上篇文章写了关于context 源码解读，里面涉及到不少的计时器，所以我们这篇文章就简单了解下go的计时器。Go的计时器主要Timer和Ticker两种，下面我们开始一起学习下

计时器主要结构

go的计时器基于Go运行时计时器runtime.timer实现的，rumtime.timer的结构体表示如下

type runtimeTimer struct {
   pp       uintptr
   when     int64
   period   int64
   f        func(interface{}, uintptr) // NOTE: must not be closure
   arg      interface{}
   seq      uintptr
   nextwhen int64
   status   uint32
}

  • p p—地址

  • when — 当前计时器被唤醒的时间；

  • period — 两次被唤醒的间隔；

  • f — 每当计时器被唤醒时都会调用的函数；

  • arg — 计时器被唤醒时调用 f 传入的参数；

  • nextWhen — 计时器处于 timerModifiedLater/timerModifiedEairlier 状态时，用于设置 when 字段；

  • status — 计时器的状态；

Timer计时器

Timer结构体

type Timer struct {
    C <-chan Time // 单向chan,将时间写入chan
    r runtimeTimer
}

Timer 方法

time.NewTimer

实例

t := time.NewTimer(time.Second * 2)
defer t.Stop()
for {
   <-t.C
   fmt.Println("timer running...")
   // 重置Reset 使 t 重新开始计时
   t.Reset(time.Second * 2)

}

源码

// NewTimer创建一个新计时器，该计时器将在时间段d后在其通道上发送当前时间。
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中（NewTimer创建的一个带缓冲的channel）。Timer.C这个channel有没有接收方sendTime都可以非阻塞的将当前时间发送给Timer.C，而且sendTime中还加了双保险：通过select判断Timer.C的Buffer是否已满，一旦满了会直接退出，不会阻塞。

time.After

实例

//⭐️这个例子有问题
mychan := make(chan int)

go func() {
   fmt.Println("wait 4's")
   time.Sleep(time.Second * 4)
   mychan <- 1
}()
for{
   select {
   case <-mychan:
      fmt.Println("结束了")
      // 拿掉return, 就会出现问题
       return
   case <-time.After(time.Second * 1):
      fmt.Println("wait 1's ")
   }
}

源码

//在等待持续时间过后，然后在返回的通道上发送当前时间。
//它相当于NewTimer方法。在计时器触发之前，垃圾收集器不会恢复基础计时器。
//如果效率是一个问题，请改用新定时器并调用定时器。如果不再需要定时器，请停止。
func After(d Duration) <-chan Time {
   return NewTimer(d).C
}

内存泄漏问题分析

首先我们从源码看出来，after是创建新的Timer对象的，然后我们如果把return拿掉，那么这个代码后续会一直走after，不停的创建新的对象。所以我们以后如果在for-select的情况下我们可以考虑使用其他的，如果是单独使用记得加上defer 来停止任务。

time.AfterFunc

实例

mychan := make(chan int)
time.AfterFunc(6*time.Second, func() {
   fmt.Println("you must wait 6's ")
   mychan <- 1
})

for {
   select {
   case <-mychan:
      fmt.Println("Game Over")
      return
   default:
      fmt.Println("wait 3's")
      time.Sleep(3 * time.Second)
   }
}

源码

//AfterFunc等待d 的时间段过去，然后在自己的goroutine中调用函数f。它返回一个计时器，能够用于使用其Stop方法取消调用。
func AfterFunc(d Duration, f func()) *Timer {
   t := &Timer{
      r: runtimeTimer{
         when: when(d),
         f:    goFunc,
         arg:  f,
      },
   }
   startTimer(&t.r)
   return t
}

从上面源码可以看到外面传入的f参数并非直接赋值给了运行时计时器的f，而是作为包装函数goFunc的参数传入的。goFunc会启动了一个新的goroutine来执行外部传入的函数f。这是因为所有计时器的事件函数都是由Go运行时内唯一的goroutine timerproc运行的。为了不阻塞timerproc的执行，必须启动一个新的goroutine执行到期的事件函数。

time.stop

源码

//停止计时器。如果调用停止计时器，则返回true；如果计时器已过期或已停止，则返回false。
// Stop不会关闭通道，以防止通道读取错误。对于使用AfterFunc（d，f）创建的计时器，
// 如果t.Stop返回false，则计时器已过期，并且函数f已在其自己的goroutine中启动；
// Stop不会在返回前等待f完成。如果调用方需要知道f是否已完成，则必须显式地与f协调
func (t *Timer) Stop() bool {
   if t.r.f == nil {
      panic("time: Stop called on uninitialized Timer")
   }
   return stopTimer(&t.r)
}

time.Reset

源码

//Reset会将计时器更改为在d时间段后过期。如果计时器处于active，则返回true；
//如果计时器已过期或已停止，则返回false。我们应该在已停止或过期且chan为空的计时器上调用Reset。
//如果一个程序已经从t.C.接收到一个值，则已知定时器已过期，通道已耗尽，因此可以直接使用t.Reset。
//重置计时器时必须注意不要与当前计时器到期发送时间到t.C的操作产生竞争。如果程序已经从t.C接收到值，
//则计时器是已知的已过期，并且t.Reset可以直接使用。如果程序尚未从t.C接收值，计时器必须先被停止，
//并且-如果使用t.Stop时报告计时器已过期，那么请排空其通道中值
func (t *Timer) Reset(d Duration) bool {
   if t.r.f == nil {
      panic("time: Reset called on uninitialized Timer")
   }
   w := when(d)
   active := stopTimer(&t.r)
   resetTimer(&t.r, w)
   return active
}

time.Reset存在的问题

正常的情况

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() {
   // 消费
   timer := time.NewTimer(time.Second * 5)
   for {
      // 如果过期了将，chan消费完
      if !timer.Stop() {
         <-timer.C
      }
      timer.Reset(time.Second * 5)
      select {
      // 没有过期，判断chan里的数据
      case b := <-c:
         if b == false {
            fmt.Println(time.Now(), ":recv false. continue")
            continue
         }
         // 如果为true就停止吧
         fmt.Println(time.Now(), ":recv true. return")
         return 
         //过期了
      case <-timer.C:
         fmt.Println(time.Now(), ":timer expired")
         continue
      }
   }
}()
// 阻塞用
var s string
fmt.Scanln(&s)

返回结果 

2021-08-19 13:27:56.968569 +0800 CST m=+1.002051349 :recv false. continue
2021-08-19 13:27:57.968956 +0800 CST m=+2.002434837 :recv false. continue
2021-08-19 13:27:58.971097 +0800 CST m=+3.004571872 :recv false. continue
2021-08-19 13:27:59.97512 +0800 CST m=+4.008591506 :recv false. continue
2021-08-19 13:28:00.975604 +0800 CST m=+5.009071140 :recv false. continue
2021-08-19 13:28:01.97907 +0800 CST m=+6.012533936 :recv true. return

错误情况

c := make(chan bool)

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

go func() {
   // 消费
   timer := time.NewTimer(time.Second * 5)
   for {
      // 如果过期了将，chan消费完
      if !timer.Stop() {
         <-timer.C
      }
      timer.Reset(time.Second * 5)
      select {
      // 没有过期，判断chan里的数据
      case b := <-c:
         if b == false {
            fmt.Println(time.Now(), ":recv false. continue")
            continue
         }
         // 如果为true就停止吧
         fmt.Println(time.Now(), ":recv true. return")
         return
         //过期了
      case <-timer.C:
         fmt.Println(time.Now(), ":timer expired")
         continue
      }
   }
}()
// 阻塞用
var s string
fmt.Scanln(&s)

返回结果(直接阻塞在这里)

2021-08-19 13:30:04.949688 +0800 CST m=+5.006256731 :timer expired

问题原因： 因为生产等了6秒，消费的timer已经过期了，然后在进入到!timer.Stop()（已经过期，在执行stop就为false），在timer.C（chan） 执行 <-，就抛错（阻塞住了） 

解决方法

c := make(chan bool)

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

go func() {
   // 消费
   timer := time.NewTimer(time.Second * 5)
   for {
      // 如果stop失败进去
      if !timer.Stop() {
         // <-timer.C失败直接走默认---往下接着走
         select {
         case <-timer.C:
         default:
         }
      }
      timer.Reset(time.Second * 5)
      select {
      case b := <-c:
         // false打印接着跑
         if b == false {
            fmt.Println(time.Now(), ":recv false. continue")
            continue
         }
         // 返回true就停止
         fmt.Println(time.Now(), ":recv true. return")
         return
      case <-timer.C:
         fmt.Println(time.Now(), ":timer expired")
         continue
      }
   }
}()

// 阻塞用
var s string
fmt.Scanln(&s)

Ticker

time.Tick

源码

//Tick是NewTicker的一个方便使用的包，仅提供对ticking chan 的访问.
// 返回tick的chan，如果d <= 0 则返回 nil
func Tick(d Duration) <-chan Time {
   if d <= 0 {
      return nil
   }
   return NewTicker(d).C
}

注意： time.Tick底层的Ticker不能被垃圾收集器恢复。

time.NewTicker

源码

// NewTicker返回一个新的Ticker，其中包含chan，chan将以d 参数指定的时间段发送时间。
func NewTicker(d Duration) *Ticker {
   if d <= 0 {
      panic(errors.New("non-positive interval for NewTicker"))
   }
   // 为chan提供一个一个元素的时间类型缓冲。
   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
}

stop

// 关闭 Ticker, 不会关闭chan，以防止因并发读取到错误的 tick 的chan信息
func (t *Ticker) Stop() {
   stopTimer(&t.r)
}

实例

ticker := time.NewTicker(time.Second * 1)
go func() {
   for t := range ticker.C {
      fmt.Println("i am come at ", t)
   }
}()

time.Sleep(time.Second * 5)
ticker.Stop()

tick和timer区别

看了创建方法的时候应该可以知道，Ticker 中的runtimeTimer字段的 period 字段会赋值为 NewTicker(d Duration) 中的d，表示每间隔d纳秒，Timer定时器就周期性地触发时间事件，timer触发一次

推荐阅读

Go 内存泄露之痛，这篇把 Go timer.After 问题根因讲透了！icon-default.png?t=L892https://mp.weixin.qq.com/s/KSBdPkkvonSES9Z9iggElgGo语言计时器的使用详解icon-default.png?t=L892https://mp.weixin.qq.com/s/QahprdKrlcaatG8poWsNrA难以驾驭的 Go timer，一文带你参透计时器的奥秘icon-default.png?t=L892https://mp.weixin.qq.com/s/gxX-q2EvgWZEWe-deRITSw

 

木子林_
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
go语言Timer计时器的用法示例详解
09-16
Go语言的标准库里提供两种类型的计时器Timer和Ticker。这篇文章通过实例代码给大家介绍go语言Timer计时器的用法，代码简单易懂，感兴趣的朋友跟随小编一起看看吧
计时器timer
03-04
计时器在各种编程语言和框架中都有实现，例如JavaScript中的`setTimeout`和`setInterval`，Java中的`java.util.Timer`，或者在iOS和Android开发中的各种定时器API。它们用于在指定的时间间隔后执行一段代码，常用于...
go语言中Timer和Ticker两种计时器
m0_53328239的博客
05-04 745
go语言中有Timer和Ticker这样的两种计时器，两种计时器分别实现了不同的计时功能。Timer是单次时间事件，指在指定的单次时间过后触发，然后向自己channel中发送当时时间，此后Timer不再计时。Ticker是多次时间事件，指每隔一段事件都触发一次，并向自己channel发送当前时间。类似于javascript中的setTimeout()和setInterval()两种计时器。
Swoole学习笔记——timer::tick和timer::after
qq_42683219的博客
08-10 1896
一、官网tick和after （1）Timer::tick 设置一个间隔时钟定时器，与after定时器不同的是tick定时器会持续触发，直到调用Timer::clear清除。 函数原型 int Swoole\Timer::tick(int $msec, callable $callback, ...$params); 别名：swoole_timer_tick 参数 ①：$msec 指定时间，单位...
HarmonyOS实战——TickTimer定时器组件基本使用
兮动人
09-13 7671
TickTimer定时器组件说明： 是Text的子类，所以可以使用Text的一些属性 该组件目前有一些bug，后续版本中会修复这些bug的 bug汇总： 不要用 setBaseTimer 去设置基准时间。 停止之后不用重新开始。 常见属性： 属性名 功能说明 format 设置显示的格式 count_down true倒着计时，false正着计时 常见方法： ...
Go~并发编程runtime、workerPool、timer、ticker、sync、atomic
Shangxingya的博客
03-27 711
文章目录前言并发的一些概念进程和线程并发和并行协程和线程runtime包runtime.Gosched()runtime.Goexit()runtime.GOMAXPROCSGoroutine池（Pool）worker pool（goroutine池）定时器Timer（只执行一次）Ticker（时间到了多次执行）并发安全和锁（Sync）sync.WaitGroup互斥锁（sync.Mutex）读写互斥锁（sync.RWMutex）惰性初始化（sync.Once）加载配置文件示例闭包下的惰性加载sync.Ma
【Go】并发编程之 计时器
weixin_44211968的博客
02-22 420
文章目录一、Timer：时间到了，执行只执行1次二、Ticker：时间到了，多次执行参考链接 一、Timer：时间到了，执行只执行1次 package main import ( "fmt" "time" ) func main() { // 1.timer基本使用 //timer1 := time.NewTimer(2 * time.Second) //t1 := time.Now() //fmt.Printf("t1:%v\n", t1) //t2 := <-timer1.C
Timer_基于Verilog的timer计时器_
10-02
在这个项目中，我们关注的是一个基于Verilog硬件描述语言实现的Timer计时器。Verilog是一种广泛使用的硬件描述语言，它允许设计师以结构化的方式描述数字系统的逻辑行为，并可被综合成实际的电路。 Timer的基本工作...
Java计时器Timer和TimerTask用法总结
最新发布
09-14
Java 计时器 Timer 和 TimerTask 用法总结 Java 中的计时器（Timer）和 TimerTask 是一种常用的延迟执行技术，用于实现延迟执行某个任务或事件。下面将详细介绍 Timer 和 TimerTask 的用法和实现原理。 Timer ...
【Golang】——利用time.Ticker做定时任务
汤庆
11-21 4303
一、前言 golang 的time.Ticker一般用来作为时间周期执行任务的。 二、demo 这个是官网贴出的例子，作用是每10s钟会输出当前的时间。 package main import ( "fmt" "time" ) func main() { ticker := time.NewTicker(time.Second) defer ticker.Stop() done := make(chan bool) go func() { time.Sle...
【鸿蒙开发日常记录】TickTimer（计时器）
weixin_45261707的博客
08-08 1314
【鸿蒙开发日常记录】TickTimer（计时器） HarmonyOS关方Java API接口文档为英文, 本系列根据笔者开发需要将文档进行总结并翻译. HarmonyOS提供的**计时器(定时器)**组件, 提供了Java接口. 组件简介: TickTimer是Text类的子类. TickTimer类提供了一个 从基准时间(base time)开始正计时 (Count up) 或倒计时 (Count down) 的计时器. 内嵌类 TickTimer.TickListener 此内嵌类提供了一个接口函数 o
C#学习之time控件和timer_tick事件
热门推荐
雍王爷的博客
04-19 3万+
Timer控件：Timer控件只有绑定了Tick事件，和设置Enabled=True后才会自动计时，停止计时可以用Stop()控制，通过Stop()停止之后，如果想重新计时，可以用Start()方法来启动计时器。Timer控件和它所在的Form属于同一个线程； timer1_Tick：是Timer对象的一个事件，表示在设定的时间间隔后自动触发的事件。比如说我们想执行一段代码功能 时间间隔为1秒。
go time.NewTicker
shunuanwei的博客
12-23 1081
go time.NewTicker 今天学习,做一下笔记,也留一个问题,大家可以试着解决一下 func main() { tk := time.NewTicker(time.Second) a := 0 in := make(chan int, 1) go func() { for true { <-tk.C a++ if a >= 5 { in <- 9 } fmt.Println(a) } }() for true {
C#中Timer使用及解决重入问题
lyc1992的专栏
12-09 1691
[摘要]本文是对C#中Timer使用及解决重入问题的讲解，对学习C#编程技术有所帮助,与大家分享。 ★前言   打开久违的Live Writer，又已经好久没写博客了，真的太懒了。废话不多说了，直接进入这次博客的主题--Timer。为什么要写这个呢，因为前几天应朋友之邀，想做个“黑客”小工具，功能挺简单就是自动获取剪贴板的内容然后发送邮件，就需要用到Timer来循环获取剪贴板
go timer 计时器用法示例
大叶子不小的博客
01-25 382
计时器用来定时执行任务，分享一段代码： package main import "time" import "fmt" func main() { //新建计时器，两秒以后触发，go触发计时器的方法比较特别，就是在计时器的channel中发送值 timer1 := time.NewTimer(time.Second * 2) //此处在等待channel中的信号，执行此段代码时会阻塞两秒 <-timer1.C fmt.Println("Timer 1 expired
Go语言版黑白棋(八)：倒计时
dodod2012的专栏
08-10 538
原文地址：https://blog.csdn.net/tennysonsky/article/details/79309793 功能说明 通过定时器实现倒计时功能，时间为20s，时间到后，如果没有落子，让对方下。 示例代码 package main import ( "fmt" "os" "strconv" "unsafe" "github...
C# timer_Tick () 事件不执行可能的原因之一，刚刚遇到的问题
cn_514的博客
04-29 9319
原来是在窗体拖得timer控件，一直不执行timer_Tick ()，后来用下边的方式可以 System.Timers.Timer类 如果是拖得控件可以 窗体名.Designer.cs 这个文件中将 timer控件的命名空间改为 System.Timers System.Timers.Timer tm = new System.Timers.Timer(1000);//实例化T...
go NewTimer计时器示例
05-03
好的，以下是一个使用 `time.NewTimer()` 创建计时器的示例： ```go package main import ( "fmt" "time" ) func main() { timer := time.NewTimer(2 * time.Second) fmt.Println("计时器已启动") <-timer.C // 阻塞等待计时器的时间到达 fmt.Println("时间到！") } ``` 在上面的示例中，我们通过 `time.NewTimer()` 创建了一个 2 秒的计时器。然后通过 `<-timer.C` 阻塞等待计时器的时间到达，一旦到达时间，程序会继续执行，打印出 "时间到！" 的消息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

木子林_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值