«

golang定时器Timer的用法和实现原理是什么

时间:2024-7-7 08:59     作者:韩俊     分类: Go语言


本篇内容介绍了“golang定时器Timer的用法和实现原理是什么”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!

    Timer

    Timer
    是一种单一事件的定时器,即经过指定的时间后触发一个事件,因为
    Timer
    只执行一次就结束,所以称为单一事件,这个事件通过其本身提供的
    channel
    进行通知触发。

    timer结构体

    通过

    src/time.sleep.go:Timer
    定义了
    Timer
    数据结构:

    // Timer代表一次定时,时间到达后仅执行一个事件。
    type Timer struct {
        C <-chan Time
        r runtimeTimer
    }

    它提供了一个

    channel
    ,在定时时间到达之前,没有数据写入
    timer.C
    会一直阻塞,直到时间到达,向
    channel
    写入系统时间,阻塞解除,可以从中读取数据,这就是一个事件。

    创建定时器

    func NewTimer(d Duration) *Timer

    通过上面方法指定一个事件即可创建一个Timer,Timer一经创建便开始计时,不需要额外的启动命令。

    示例:

    func main()  {
        timer := time.NewTimer(time.Second * 5) //设置超时时间5s
    
        <- timer.C
        fmt.Println("Time out!")
    }

    停止定时器

    Timer创建后可以随时停止,停止计时器的方法如下:

    func (t *Timer) Stop() bool

    其返回值代表定时器有没有超时:

      true:定时器超时前停止,后续不会再有事件发送。

      false:定时器超时后停止。

    示例:

    func main()  {
        timer := time.NewTimer(time.Second * 5) //设置超时时间5s
        timer.Stop()
    }

    重置定时器

    已经过期的定时器或者已停止的定时器,可以通过重置动作重新激活,方法如下:

    func (t *Timer) Reset(d Duration) bool

    重置的动作本质上是先停掉定时器,再启动,其返回值也即是停掉计时器的返回值。

    func main()  {
        timer := time.NewTimer(time.Second * 5)
    
        <- timer.C
        fmt.Println("Time out!")
    
        timer.Stop() 
        timer.Reset(time.Second*3)  // 重置定时器
    }

    实现原理

    每个Go应用程序都有一个协程专门负责管理所有的Timer,这个协程负责监控Timer是否过期,过期后执行一个预定义的动作,这个动作对于Timer而言就是发送当前时间到管道中。

    数据结构

    type Timer struct {
        C <-chan Time
        r runtimeTimer
    }

    Timer只有两个成员:

      C:channel,上层应用根据此管道接收事件;

      r:runtimeTimer定时器,该定时器即系统管理的定时器,上层应用不可见。

    runtimeTimer

    任务的载体,用于监控定时任务,每创建一个Timer就创建一个runtimeTimer变量,然后把它交给系统进行监控,我们通过设置runtimeTimer过期后的行为来达到定时的目的。

    源码包src/time/sleep.go:runtimeTimer定义了其数据结构:

    type runtimeTimer struct {
        tb uintptr                          // 存储当前定时器的数组地址
        i  int                              // 存储当前定时器的数组下标
    
        when   int64                        // 当前定时器触发时间
        period int64                        // 当前定时器周期触发间隔
        f      func(interface{}, uintptr)   // 定时器触发时执行的函数
        arg    interface{}                  // 定时器触发时执行函数传递的参数一
        seq    uintptr                      // 定时器触发时执行函数传递的参数二(该参数只在网络收发场景下使用)
    }

    创建Timer

    源码实现:

    func NewTimer(d Duration) *Timer {
        c := make(chan Time, 1)  // 创建一个管道
        t := &Timer{ // 构造Timer数据结构
            C: c,               // 新创建的管道
            r: runtimeTimer{
                when: when(d),  // 触发时间
                f:    sendTime, // 触发后执行函数sendTime
                arg:  c,        // 触发后执行函数sendTime时附带的参数
            },
        }
        startTimer(&t.r) // 此处启动定时器,只是把runtimeTimer放到系统协程的堆中,由系统协程维护
        return t
    }

      NewTimer()
      只是构造了一个
      Timer
      ,然后把
      Timer.r
      通过
      startTimer()
      交给系统协程维护。

      C 是一个带1个容量的chan,这样做有什么好处呢,原因是chan 无缓冲发送数据就会阻塞,阻塞系统协程,这显然是不行的。

      回调函数设置为

      sendTime
      ,执行参数为
      channel
      sendTime
      就是到点往C 里面发送当前时间的函数

    sendTime实现:

    //c interface{} 就是NewTimer 赋值的参数,就是channel
    func sendTime(c interface{}, seq uintptr) {
        select {
        case c.(chan Time) <- Now(): //写不进去的话,C 已满,走default 分支
        default:
        }
    }

    停止Timer

    停止Timer,就是把Timer从系统协程中移除。函数主要实现如下:

    func (t *Timer) Stop() bool {
        return stopTimer(&t.r)
    }

    stopTimer()即通知系统协程把该Timer移除,即不再监控。系统协程只是移除Timer并不会关闭管道,以避免用户协程读取错误。

    重置Timer

    重置Timer时会先把timer从系统协程中删除,修改新的时间后重新添加到系统协程中。

    func (t *Timer) Reset(d Duration) bool {
        w := when(d)
        active := stopTimer(&t.r)
        t.r.when = w
        startTimer(&t.r)
        return active
    }

    补充:golang定时器Ticker

    time包下有一个Ticker结构体

    // Ticker保管一个通道,并每隔一段时间向其传递"tick"。
    type Ticker struct {
        C <-chan Time // 周期性传递时间信息的通道.
        r runtimeTimer
    }
    func NewTicker(d Duration) *Ticker{}

    NewTicker返回一个新的Ticker,该Ticker包含一个通道字段,并会每隔时间段d,就向该通道发送当时的时间。它会调整时间间隔或者丢弃tick信息以适应反应慢的接收者。如果d<=0会panic。关闭该Ticker可以释放相关资源。

    func (t *Ticker) Stop()

    Stop关闭一个Ticker。在关闭后,将不会发送更多的tick信息。Stop不会关闭通道t.C,以避免从该通道的读取不正确的成功。

    例子

    package main
    
    import (
        "fmt"
        "time"
    )
    
    func main() {
        t := time.NewTicker(5 * time.Second) //创建定时器
        defer t.Stop()
        
        go sync(t)
        select {
    
        }
    }
    
    func sync(t *time.Ticker) {
        for {
            // 每5秒中从chan t.C 中读取一次
            <-t.C
            fmt.Println("执行数据备份任务:", time.Now().Format("2006-01-02 15:04:05"))
        }
    }

    标签: golang

    热门推荐