zoukankan      html  css  js  c++  java
  • Go定时器--Timer

    前言

    Go提供了两种定时器, 即 一次性定时器周期定时器

    • 一次性定时器:定时器只计时一次,结束便停止
    • 周期定时器:定时器周期性进行计时

    本篇将快速介绍这两种定时器的基本用法,重点介绍其内部实现原理,最后再给出一个案例揭示使用定时器的风险。

    Timer 定时器

    简介

    Timer实际上是一种单一事件的定时器,即经过指定的时间后触发一个事件,这个事件通过其本身提供的channel进行通知。之所以叫单一事件,是因为Timer只执行一次就结束,这也是Timer与Ticker的最重要的区别之一。

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

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

    Timer对外仅暴露一个channel,指定的时间到来时就往该channel中写入系统时间,也即一个事件。

    使用场景

    1. 设定超时时间

    有时我们希望从一个管道中读取数据,在管道中没有数据时,我们不想让程序永远阻塞在管道中,而是设定一个超时时间,在此时间段中如果管道中还是没有数据到来,则判定为超时。

    比如从一个连接中等待数据,其简单的用法如下代码所示:

    func waitChannel(conn <-chan string) bool {
        timer := time.NewTimer(1 * time.Second) //设置超时时间 1s
        
        select {
            case <- conn:
            timer.stop() // 接收到数据后,要停止计时器
            return true
        case timer.C: //超时判断
            fmt.Println("WaitChnel timeout!")
            return false
        }
    }
    

    WaitChannel作用就是检测指定的管道中是否有数据到来,通过select语句轮询conn和timer.C两个管道,timer会在1s后向timer.C写入数据,如果1s内conn还没有数据,则会判断为超时。

    2. 延迟执行某个方法

    有时我们希望某个方法在今后的某个时刻执行,如下代码所示:

    func DelayFunction() {
        timer := time.NewTimer(5 * time.Second)
    
        select {
        case <- timer.C:
            log.Println("Delayed 5s, start to do something.")
            // do something
        }
    }
    

    DelayFunction()会一直等待timer的事件到来才会执行后面的方法(打印)。

    Timer对外接口

    1. 创建定时器

    使用方法,func NewTimer(d Duration) *Timer 指定一个时间即可创建一个Timer,Timer一经创建便开始集是, 不需要额外的启动命令。

    实际上,创建Timer意味着把一个计时任务交给系统守护协程,该协程管理着所有的Timer,当Timer的时间到达后向Timer的管道中发送当前的时间作为事件。详细的实现原理我们后面会单独介绍。

    2. 停止定时器

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

    func (t *Timer) Stop() bool
    

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

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

    实际上,停止计时器意味着通知系统守护协程移除该定时器。详细的实现原理我们后面单独介绍。

    3. 重置定时器

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

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

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

    需要注意的是,重置定时器虽然可以用于修改还未超时的定时器,但正确的使用方式还是针对已过期的定时器或已被停止的定时器,同时其返回值也不可靠,返回值存在的价值仅仅是与前面版本兼容。

    实际上,重置定时器意味着通知系统守护协程移除该定时器,重新设定时间后,再把定时器交给守护协程

    其他接口

    前面介绍了Timer的标准接口,time包同时还提供了一些简单的方法,在特定的场景下可以简化代码。

    1. After()

    有时我们就是想等指定的时间,没有需求提前停止定时器,也没有需求复用该定时器,那么可以使用匿名的定时器。

    func After(d Duration) <-chan Time方法创建一个定时器,并返回定时器的管道,如下代码所示:

    func AfterDemo() {
        log.Println(time.Now())
        <- time.After(1 * time.Second)
        log.Println(time.Now())
    }
    

    AfterDemo()两条打印时间间隔为1s,实际还是一个定时器,但代码变得更简洁。

    2. AferFunc()

    前面我们例子中讲到延迟一个方法的调用,实际上通过AfterFunc可以更简洁。AfterFunc的原型为:

    func AfterFunc(d Duration, f func()) *Timer
    

    该方法在指定时间到来后会执行函数f。例如:

    func AfterFuncDemo() {
        log.Println("AfterFuncDemo start: ", time.Now())
        time.AfterFunc(1 * time.Second, func() {
            log.Println("AfterFuncDemo end: ", time.Now())
        })
    
        time.Sleep(2 * time.Second) // 等待协程退出
    }
    

    AfterFuncDemo()中先打印一个时间,然后使用AfterFunc启动一个定器,并指定定时器结束时执行一个方法打印结束时间。

    与上面的例子所不同的是,time.AfterFunc()是异步执行的,所以需要在函数最后sleep等待指定的协程退出,否则可能函数结束时协程还未执行。

    总结

    Timer内容总结如下:

    • time.NewTimer(d)创建一个Timer;
    • timer.Stop()停掉当前Timer;
    • timer.Reset(d)重置当前Timer;

    Timer实现原理

    前言

    很多人想当然的以为,启动一个Timer意味着启动了一个协程,这个协程会等待Timer到期,然后向Timer的管道中发送当前时间。

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

    数据结构

    1. Timer

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

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

    Timer只有两个成员:

    • C: 管道,上层应用根据此管道接收事件;
    • r: runtime定时器,该定时器即系统管理的定时器,对上层应用不可见;

    这里应该按照层次来理解Timer数据结构,Timer.C即面向Timer用户的,Timer.r是面向底层的定时器实现。

    2.runtimeTimer

    创建一个Timer实质上是把一个定时任务交给专门的协程进行监控,这个任务的载体便是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都由底层的一个协程来管理,为了描述方便我们把这个协程称为系统协程。

    系统协程把runtimeTimer存放在数组中,并按照when字段对所有的runtimeTimer进行堆排序,定时器触发时执行runtimeTimer中的预定义函数f,即完成了一次定时任务。

    1. 创建Timer

    创建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()交给系统协程维护。

    其中when()方法是计算下一次定时器触发的绝对时间,即当前时间+NewTimer()参数d。

    其中sendTime()方法便是定时器触发时的动作:

    func sendTime(c interface{}, seq uintptr) {
        select {
        case c.(chan Time) <- Now():
        default:
        }
    }
    

    sendTime接收一个管道作为参数,其主要任务是向管道中写入当前时间。

    创建Timer时生成的管道含有一个缓冲区(make(chan Time, 1)),所以Timer触发时向管道写入时间永远不会阻塞,sendTime写完即退出。

    之所以sendTime()使用select并搭配一个空的default分支,是因为后面所要讲的Ticker也复用sendTime(),Ticker触发时也会向管道中写入时间,但无法保证之前的数据已被取走,所以使用select并搭配一个空的default分支,确保sendTime()不会阻塞,Ticker触发时,如果管道中还有值,则本次不再向管道中写入时间,本次触发的事件直接丢弃。

    startTimer(&t.r)的具体实现在runtime包,其主要作用是把runtimeTimer写入到系统协程的数组中,并启动系统协程(如果系统协程还未开始运行的话)。更详细的内容,待后面讲解系统协程时再介绍。

    综上,创建一个Timer示意图如下:

    2. 停止Timer

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

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

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

    系统协程监控Timer是否需要触发,Timer触发后,系统协程会删除该Timer。所以在Stop()执行时有两种情况:

    • Timer还未触发,系统协程已经删除该Timer,Stop()返回false;
    • Timer已经触发,系统协程还未删除该Timer,Stop()返回true;

    综上,停止一个Timer示意图如下:

    3. 重置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
    }
    

    其返回值与Stop()保持一致,即如果Timer成功停止,则返回true,如果Timer已经触发,则返回false。

    重置一个Timer示意图如下:

    由于新加的Timer时间很可能变化,所以其在系统协程的位置也会发生变化(按顺序排列)。

    按照官方说明,Reset()应该作用于已经停掉的Timer或者已经触发的Timer,按照这个约定其返回值将总是返回false,之所以仍然保留是为了保持向前兼容,使用老版本Go编写的应用不需要因为Go升级而修改代码

    如果不按照此约定使用Reset(),有可能遇到Reset()和Timer触发同时执行的情况,此时有可能会收到两个事件,从而对应用程序造成一些负面影响,使用时一定要注意。

    总结

    • NewTimer()创建一个新的Timer交给系统协程监控;
    • Stop()通知系统协程删除指定的Timer;
    • Reset()通知系统协程删除指定的Timer并再添加一个新的Timer;

    参考

    地鼠编程

    ♥永远年轻,永远热泪盈眶♥
  • 相关阅读:
    tcpdump使用技巧
    linux: 系统调用
    linux命令:rsync, 同步文件和文件夹的命令
    编译kernel:make Image uImage与zImage的区别
    linux下操作gpio寄存器的方法
    Linux输入子系统(Input Subsystem)
    Android电源管理基础知识整理
    【Android休眠】之Android休眠机制
    拓扑排序入门(真的很简单)
    有向无环图的拓扑排序
  • 原文地址:https://www.cnblogs.com/failymao/p/15064059.html
Copyright © 2011-2022 走看看