登录
首页 >  Golang >  Go教程

Go timer如何调度

来源:脚本之家

时间:2022-12-31 20:14:34 160浏览 收藏

知识点掌握了,还需要不断练习才能熟练运用。下面golang学习网给大家带来一个Golang开发实战,手把手教大家学习《Go timer如何调度》,在实现功能的过程中也带大家重新温习相关知识点,温故而知新,回头看看说不定又有不一样的感悟!

本篇文章剖析下 Go 定时器的相关内容。定时器不管是业务开发,还是基础架构开发,都是绕不过去的存在,由此可见定时器的重要程度。

我们不管用 NewTimer, timer.After,还是 timer.AfterFun 来初始化一个 timer, 这个 timer 最终都会加入到一个全局 timer 堆中,由 Go runtime 统一管理。

全局的 timer 堆也经历过三个阶段的重要升级。

  • Go 1.9 版本之前,所有的计时器由全局唯一的四叉堆维护,协程间竞争激烈。
  • Go 1.10 - 1.13,全局使用 64 个四叉堆维护全部的计时器,没有本质解决 1.9 版本之前的问题
  • Go 1.14 版本之后,每个 P 单独维护一个四叉堆。

Go 1.14 以后的 timer 性能得到了质的飞升,不过伴随而来的是 timer 成了 Go 里面最复杂、最难梳理的数据结构。本文不会详细分析每一个细节,我们从大体来了解 Go timer 的工作原理。

1. 使用场景

Go timer 在我们代码中会经常遇到。

场景1:RPC 调用的防超时处理(下面代码节选 dubbogo)

func (c *Client) Request(request *remoting.Request, timeout time.Duration, response *remoting.PendingResponse) error {
    _, session, err := c.selectSession(c.addr)
    // .. 省略
    if totalLen, sendLen, err = c.transfer(session, request, timeout); err != nil {
        if sendLen != 0 && totalLen != sendLen {
          // .. 省略
        }
        return perrors.WithStack(err)
    }

    // .. 省略
    select {
    case 

<p>场景2:Context 的超时处理</p>

<pre class="brush:plain;">
func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel()
    go doSomething()
    
    select {
    case 

<h2>2. 图解源码</h2>
<h3>2.1 四叉堆原理</h3>
<p>timer 的全局堆是一个四叉堆,特别是 Go 1.14 之后每个 P 都会维护着一个四叉堆,减少了 Goroutine 之间的并发问题,提升了 timer 了性能。</p>
<p>四叉堆其实就是四叉树,Go timer 是如何维护四叉堆的呢?</p>
  • Go runtime 调度 timer 时,触发时间更早的 timer,要减少其查询次数,尽快被触发。所以四叉树的父节点的触发时间是一定小于子节点的。
  • 四叉树顾名思义最多有四个子节点,为了兼顾四叉树插、删除、重排速度,所以四个兄弟节点间并不要求其按触发早晚排序。

这里用两张动图简单演示下 timer 的插入和删除

把 timer 插入堆

把 timer 从堆中删除

2.2 timer 是如何被调度的?

调用 NewTimer,timer.After, timer.AfterFunc 生产 timer, 加入对应的 P 的堆上。

调用 timer.Stop, timer.Reset 改变对应的 timer 的状态。

GMP 在调度周期内中会调用 checkTimers ,遍历该 P 的 timer 堆上的元素,根据对应 timer 的状态执行真的操作。

2.3 timer 是如何加入到 timer 堆上的?

把 timer 加入调度总共有下面几种方式:

  • 通过 NewTimer, time.After, timer.AfterFunc 初始化 timer 后,相关 timer 就会被放入到对应 p 的 timer 堆上。
  • timer 已经被标记为 timerRemoved,调用了 timer.Reset(d),这个 timer 也会重新被加入到 p 的 timer 堆上
  • timer 还没到需要被执行的时间,被调用了 timer.Reset(d),这个 timer 会被 GMP 调度探测到,先将该 timer 从 timer 堆上删除,然后重新加入到 timer 堆上
  • STW 时,runtime 会释放不再使用的 p 的资源,p.destroy()->timer.moveTimers,将不再被使用的 p 的 timers 上有效的 timer(状态是:timerWaiting,timerModifiedEarlier,timerModifiedLater) 都重新加入到一个新的 p 的 timer 上

2.4 Reset 时 timer 是如何被操作的?

Reset 的目的是把 timer 重新加入到 timer 堆中,重新等待被触发。不过分为两种情况:

  • 被标记为 timerRemoved 的 timer,这种 timer 是已经从 timer 堆上删除了,但会重新设置被触发时间,加入到 timer 堆中
  • 等待被触发的 timer,在 Reset 函数中只会修改其触发时间和状态(timerModifiedEarlier或timerModifiedLater)。这个被修改状态的 timer 也同样会被重新加入到 timer堆上,不过是由 GMP 触发的,由 checkTimers 调用 adjusttimers 或者 runtimer 来执行的。

2.5 Stop 时 timer 是如何被操作的?

time.Stop 为了让 timer 停止,不再被触发,也就是从 timer 堆上删除。不过 timer.Stop 并不会真正的从 p 的 timer 堆上删除 timer,只会将 timer 的状态修改为 timerDeleted。然后等待 GMP 触发的 adjusttimers 或者 runtimer 来执行。

真正删除 timer 的函数有两个 dodeltimer,dodeltimer0。

2.6 Timer 是如何被真正执行的?

timer 的真正执行者是 GMP。GMP 会在每个调度周期内,通过 runtime.checkTimers 调用 timer.runtimer(). timer.runtimer 会检查该 p 的 timer 堆上的所有 timer,判断这些 timer 是否能被触发。

如果该 timer 能够被触发,会通过回调函数 sendTime 给 Timer 的 channel C 发一个当前时间,告诉我们这个 timer 已经被触发了。

如果是 ticker 的话,被触发后,会计算下一次要触发的时间,重新将 timer 加入 timer 堆中。

3. Timer 使用中的坑

确实 timer 是我们开发中比较常用的工具,但是 timer 也是最容易导致内存泄露,CPU 狂飙的杀手之一。

不过仔细分析可以发现,其实能够造成问题就两个方面:

  • 错误创建很多的 timer,导致资源浪费
  • 由于 Stop 时不会主动关闭 C,导致程序阻塞

3.1 错误创建很多 timer,导致资源浪费

func main() {
    for {
        // xxx 一些操作
        timeout := time.After(30 * time.Second)
        select {
        case 

<p>上面这段代码是造成 timer 异常的最常见的写法,也是我们最容易忽略的写法。</p>
<p>造成问题的原因其实也很简单,因为 timer.After 底层是调用的 timer.NewTimer,NewTimer 生成 timer 后,会将 timer 放入到全局的 timer 堆中。</p>
<p>for 会创建出来数以万计的 timer 放入到 timer 堆中,导致机器内存暴涨,同时不管 GMP 周期 checkTimers,还是插入新的 timer 都会疯狂遍历 timer 堆,导致 CPU 异常。</p>
<p>要注意的是,不只 time.After 会生成 timer, NewTimer,time.AfterFunc 同样也会生成 timer 加入到 timer 中,也都要防止循环调用。</p>
<p>解决办法: 使用 time.Reset 重置 timer,重复利用 timer。</p>
<p>我们已经知道 time.Reset 会重新设置 timer 的触发时间,然后将 timer 重新加入到 timer 堆中,等待被触发调用。</p>

<pre class="brush:plain;">
func main() {
    timer := time.NewTimer(time.Second * 5)    
    for {
        t.Reset(time.Second * 5)

        select {
        case 

<h3>3.2 程序阻塞,造成内存或者 goroutine 泄露</h3>

<pre class="brush:plain;">
func main() {
    timer1 := time.NewTimer(2 * time.Second)
    

<p>上面的代码可以看出来,只有等待 timer 超时 "done" 才会输出,原理很简单:程序阻塞在 
</p><p>不过使用 timer.Stop 的时候就要特别注意了,比如:</p>

<pre class="brush:plain;">
func main() {
    timer1 := time.NewTimer(2 * time.Second)
    go func() {
        timer1.Stop()
    }()
    

<p>程序就会一直死锁了,因为 timer1.Stop 并不会关闭 channel C,使程序一直阻塞在 timer1.C 上。</p>
<p>上面这个例子过于简单了,试想下如果 
</p><p>Stop 的正确的使用方式:</p>

<pre class="brush:plain;">
func main() {
    timer1 := time.NewTimer(2 * time.Second)
    go func() {
        if !timer1.Stop() {
            

<p>终于介绍完啦!小伙伴们,这篇关于《Go timer如何调度》的介绍应该让你收获多多了吧!欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识,快来关注吧!</p>
声明:本文转载于:脚本之家 如有侵犯,请联系study_golang@163.com删除
相关阅读
更多>
最新阅读
更多>
课程推荐
更多>
评论列表