【Golang】关于Go语言中的定时器原理与实战应用

景天科技苑2024-10-13 15:44

✨✨ 欢迎大家来到景天科技苑✨✨

🎈🎈 养成好习惯，先赞后看哦~🎈🎈

🏆 作者简介：景天科技苑

🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。

🏆《博客》：Python全栈，Golang开发，PyQt5和Tkinter桌面开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi，flask等框架，云原生K8S，linux，shell脚本等实操经验，网站搭建，数据库等分享。

所属的专栏： Go语言开发零基础到高阶实战
景天的主页： 景天科技苑

文章目录

  • Go语言中的定时器
    • 一、Timer定时器
      • [1. 创建Timer](#1. 创建Timer)
      • [2. 停止Timer](#2. 停止Timer)
      • [3. 重置Timer](#3. 重置Timer)
      • [4. time.AfterFunc](#4. time.AfterFunc)
      • [5. time.After](#5. time.After)
    • 二、Ticker定时器
      • [1. 创建Ticker](#1. 创建Ticker)
      • [2. 监听Ticker事件](#2. 监听Ticker事件)
      • [3. 停止Ticker定时器](#3. 停止Ticker定时器)
    • 三、定时器应用案例
      • [1. 定时打印日志](#1. 定时打印日志)
      • [2. 周期性检查系统状态](#2. 周期性检查系统状态)
    • 四、总结

Go语言中的定时器

在Go语言中，定时器是并发编程中常用的工具之一。定时器可以用于监控某个goroutine的运行时间、定时打印日志、周期性执行任务等多种场景。

Go标准库提供了两种主要的定时器：Timer（一次性定时器）和Ticker（周期性定时器）。本文将详细介绍这两种定时器的用法，并通过实际案例展示其应用场景。

一、Timer定时器

Timer定时器是一种一次性定时器，即在未来某个时刻触发的事件只会执行一次。

Timer的结构中包含一个Time类型的管道C，主要用于事件通知。

在未到达设定时间时，管道内没有数据写入，一直处于阻塞状态；到达设定时间后，会向管道内写入一个系统时间，触发事件。

1. 创建Timer

使用time.NewTimer函数可以创建一个Timer定时器。该函数接受一个Duration类型的参数，表示定时器的超时时间，并返回一个*Timer类型的指针。

看下源码，Timer结构体中，timer.C是一个时间类型的通道

go 复制代码 
package main

import (
    "fmt"
    "time"
)

func main() {
    // func NewTimer(d Duration) *Timer
    timer := time.NewTimer(2 * time.Second) // 设置超时时间2秒
    // 先打印下当前时间
    fmt.Println("当前时间:", time.Now())

    //我们可以打印下这个只读通道的值
        //timer.C就是我们在定义定时器的时候，存放的时间，等待对应的时间。现在这个就是根据当前时间加2秒

    fmt.Println("通道里面的值", <-timer.C)
}

可以看到timer.C这个只读通道里面的值，就是通过NewTimer设置时间间隔后的时间

因此，我们可以根据时间通道，来定时将来某个时间要做的事

go 复制代码 
package main

import (
    "fmt"
    "time"
)

func main() {
    timer := time.NewTimer(2 * time.Second) // 设置超时时间2秒
    <-timer.C
    //经过两秒后只想下面代码
    fmt.Println("after 2s Time out!")
}

在上述代码中，创建了一个超时时间为2秒的定时器，程序会阻塞在<-timer.C处，直到2秒后定时器触发，程序继续执行并打印"after 2s Time out!"。

2. 停止Timer

使用Stop方法可以停止一个Timer定时器。该方法返回一个布尔值，表示定时器是否在超时前被停止。

如果返回true，表示定时器在超时前被成功停止；如果返回false，表示定时器已经超时或已经被停止过。

go 复制代码 
package main

import (
    "fmt"
    "time"
)

func main() {
    timer := time.NewTimer(2 * time.Second) // 设置超时时间2秒
    //这里，创建定时器后，里面执行了停止方法，肯定是在定时器超时前停止了，返回true
    res := timer.Stop()
    fmt.Println(res) // 输出：true
}

在上述代码中，创建了一个超时时间为2秒的定时器，并立即调用Stop方法停止它。由于定时器还没有超时，所以Stop方法返回true。

3. 重置Timer

对于已经过期或者是已经停止的Timer，可以通过Reset方法重新激活它，并设置新的超时时间。Reset方法也返回一个布尔值，表示定时器是否在重置前已经停止或过期。

go 复制代码 
package main

import (
    "fmt"
    "time"
)

func main() {
    timer := time.NewTimer(2 * time.Second)
    <-timer.C
    fmt.Println("time out1")
    //经过两秒后，定时器超时了
    res1 := timer.Stop()
    //此时再stop，得到的是false
    fmt.Printf("res1 is %t\n", res1) // 输出：false
    //然后我们重置定时器。重置成3秒后超时
    timer.Reset(3 * time.Second)
    res2 := timer.Stop()
    //此时再stop，由于定时器没超时，得到的是true
    fmt.Printf("res2 is %t\n", res2) // 输出：true
}

在上述代码中，首先创建了一个超时时间为2秒的定时器，并在超时后打印"time out1"。

然后调用Stop方法停止定时器，由于定时器已经过期，所以Stop方法返回false。

接着调用Reset方法将定时器重新激活，并设置新的超时时间为3秒。

最后再次调用Stop方法停止定时器，由于此时定时器还没有过期，所以Stop方法返回true。

4. time.AfterFunc

time.AfterFunc函数可以接受一个Duration类型的参数和一个函数f，返回一个*Timer类型的指针。在创建Timer之后，等待一段时间d，然后执行函数f。

go 复制代码 
package main

import (
    "fmt"
    "time"
)

func main() {
    duration := time.Duration(1) * time.Second
    f := func() {
        fmt.Println("f has been called after 1s by time.AfterFunc")
    }
    // func AfterFunc(d Duration, f func()) *Timer
    //等待duration时间后，执行f函数
    //这里是经过1秒后。执行f函数
    timer := time.AfterFunc(duration, f)
    defer timer.Stop()
    time.Sleep(2 * time.Second)
}

在上述代码中，创建了一个超时时间为1秒的定时器，并在超时后执行函数f。

使用defer语句确保在程序结束时停止定时器。程序会在1秒后打印"f has been called after 1s by time.AfterFunc"。

5. time.After

time.After函数会返回一个*Timer类型的管道，该管道会在经过指定时间段d后写入数据。调用这个函数相当于实现了一个定时器。

go 复制代码 
package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan string)
    go func() {
        time.Sleep(3 * time.Second)
        ch <- "test"
    }()
    
    //使用select，哪个先到来，耗时时间短，执行哪个
    select {
    case val := <-ch:
        fmt.Printf("val is %s\n", val)
    // 这个case是两秒后执行
    // func After(d Duration) <-chan Time
    case <-time.After(2 * time.Second):
        fmt.Println("timeout!!!")
    }
}

在上述代码中，创建了一个管道ch，并在另一个goroutine中等待3秒后向管道写入数据。

在主goroutine中使用select语句监听两个管道：一个是刚刚创建的ch，另一个是time.After函数返回的管道c。

由于ch管道3秒后才会有数据写入，而time.After函数是2秒超时，所以2秒后select会先收到管道c里的数据，执行"timeout!!!"并退出。

二、Ticker定时器

Ticker定时器可以周期性地不断触发时间事件，不需要额外的Reset操作。Ticker的结构中也包含一个Time类型的管道C，每隔固定时间段d就会向该管道发送当前的时间，根据这个管道消息来触发事件。

Ticker定时器是Go标准库time包中的一个重要组件。它允许你每隔一定的时间间隔执行一次指定的操作。Ticker定时器在创建时会启动一个后台goroutine，该goroutine会按照指定的时间间隔不断向一个通道（Channel）发送当前的时间值。

1. 创建Ticker

要创建一个Ticker定时器，你可以使用time.NewTicker函数。这个函数接受一个time.Duration类型的参数，表示时间间隔，并返回一个*time.Ticker类型的指针。

Ticker定时器的核心是一个通道（Channel），你可以通过监听这个通道来接收时间间隔到达的事件。

go 复制代码 
ticker := time.NewTicker(1 * time.Second)

上面的代码创建了一个每隔1秒触发一次的Ticker定时器。

2. 监听Ticker事件

要监听Ticker定时器的事件，你可以使用range关键字或者select语句来监听Ticker定时器的通道。每次时间间隔到达时，Ticker定时器的通道都会接收到一个当前的时间值。

go 复制代码 
for range ticker.C {  
    // 在这里执行周期性任务  
}
go 复制代码 
package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(1 * time.Second)
    //查看定时器数据类型
    fmt.Printf("定时器数据类型%T\n", ticker)
    //启动协程来监听定时器触发事件，通过time.Sleep函数来等待5秒钟，然后调用ticker.Stop()函数来停止定时器。
    //最后，输出"定时器停止"表示定时器已经成功停止。
    go func() {
        for range ticker.C {
            fmt.Println("Ticker ticked")
        }

    }()

    //执行5秒后，让定时器停止
    time.Sleep(5 * time.Second)
    ticker.Stop()
    fmt.Println("定时器停止")
}

或者，如果你需要同时监听多个通道，你可以使用select语句：

go 复制代码 
select {  
case t := <-ticker.C:  
    // 处理Ticker定时器事件  
case <-stopChan:  
    // 处理停止信号  
}
go 复制代码 
package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(1 * time.Second) // 创建一个每秒触发一次的Ticker定时器
    defer ticker.Stop()                       // 确保在main函数结束时停止定时器

    for {
        select {
        case t := <-ticker.C:
            fmt.Println("Tick at", t)
        }
    }
}

每秒执行一次

3. 停止Ticker定时器

当你不再需要Ticker定时器时，你应该调用它的Stop方法来停止它。停止Ticker定时器可以释放与之关联的资源，并防止不必要的goroutine继续运行。

ticker.Stop()

停止Ticker定时器后，它的通道将不再接收任何事件。

go 复制代码 
package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(500 * time.Millisecond) // 创建一个每500毫秒触发一次的Ticker定时器
    timeEnd := make(chan bool)                       // 用于停止Ticker定时器的通道

    go func() {
        for {
            select {
            //当达到设置的停止条件式，停止循环
            case <-timeEnd:
                fmt.Println("===结束任务")
                break
            case t := <-ticker.C:
                fmt.Println("==500毫秒响应一次:", t)
            }
        }
    }()

    time.Sleep(5 * time.Second) // 主线程等待5秒钟
    ticker.Stop()               // 停止Ticker定时器
    timeEnd <- true             // 发送结束信号

    fmt.Println("===定时任务结束===")
}

持续执行5秒后，定时器停止运行

三、定时器应用案例

1. 定时打印日志

Ticker定时器的一个常见应用是定时打印日志。通过设置一个Ticker定时器，你可以每隔固定的时间间隔输出一次日志信息，从而监控程序的运行状态。

go 复制代码 
package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Second)
    defer ticker.Stop() // 确保程序结束时停止Ticker定时器

    for range ticker.C {
        // 打印当前时间作为日志
        fmt.Println("Current time:", time.Now())
    }
}

5秒打印一次

在这个例子中，我们创建了一个每隔5秒触发一次的Ticker定时器，并在一个无限循环中监听它的事件。

每次事件触发时，我们都会打印当前的时间作为日志信息。注意，由于我们在main函数中使用了defer语句来确保Ticker定时器在程序结束时被停止，所以即使循环是无限的，程序也不会因为Ticker定时器而泄漏资源。

然而，在实际应用中，你可能需要在某个条件下提前停止Ticker定时器。这时，你可以使用一个额外的通道来发送停止信号：

go 复制代码 
package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Second)
    stopChan := make(chan struct{})

    go func() {
        // 模拟一个运行一段时间的任务
        time.Sleep(15 * time.Second)
        // 发送停止信号
        stopChan <- struct{}{}
    }()

    for {
        select {
        case t := <-ticker.C:
            fmt.Println("Tick at", t)
        case <-stopChan:
            fmt.Println("Ticker stopped")
            ticker.Stop()
            return
        }
    }
}

在这个例子中，我们创建了一个额外的stopChan通道来发送停止信号。我们启动了一个goroutine来模拟一个运行一段时间的任务，并在任务完成后向stopChan发送一个停止信号。

在for循环中，我们使用select语句同时监听Ticker定时器的通道和stopChan通道。当接收到停止信号时，我们停止Ticker定时器并退出程序。

2. 周期性检查系统状态

Ticker定时器还可以用于周期性检查系统状态。例如，你可以每隔一段时间检查一次服务器的负载、内存使用情况或数据库连接数等关键指标，并在发现异常时采取相应的措施。

go 复制代码 
package main

import (
    "fmt"
    "math/rand"
    "time"
)

// 模拟检查系统状态的函数
func checkSystemStatus() {
    // 这里可以添加实际的检查逻辑
    // 例如：检查CPU使用率、内存使用情况等
    // 这里我们随机生成一个0到100之间的数作为模拟结果
    status := rand.Intn(101)
    fmt.Printf("System status: %d\n", status)

    // 假设状态大于80表示系统异常
    if status > 80 {
        fmt.Println("Warning: System status is above normal!")
        // 这里可以添加处理异常的逻辑
        // 例如：发送警报、重启服务等
    }
}

func main() {
    ticker := time.NewTicker(10 * time.Second)
    defer ticker.Stop() // 确保程序结束时停止Ticker定时器

    for range ticker.C {
        checkSystemStatus()
    }
}

在这个例子中，我们创建了一个每隔10秒触发一次的Ticker定时器，并在一个无限循环中监听它的事件。

每次事件触发时，我们都会调用checkSystemStatus函数来模拟检查系统状态。checkSystemStatus函数会随机生成一个0到100之间的数作为模拟结果，并根据结果判断是否系统异常。

如果系统异常（即状态大于80），则打印警告信息，并可以在这里添加处理异常的逻辑。

同样地，你可以使用额外的通道来发送停止信号，以便在需要时提前停止Ticker定时器。

四、总结

本文详细介绍了Go语言中Timer和Ticker两种定时器的用法，并通过实际案例展示了它们的应用场景。Timer定时器适用于需要一次性触发的事件，而Ticker定时器适用于需要周期性触发的事件，希望在大家go的学习与应用上能够帮助到大家。

相关推荐
程序员爱钓鱼几秒前
Go语言实战案例-创建模型并自动迁移
后端·google·go
javachen__5 分钟前
SpringBoot整合P6Spy实现全链路SQL监控
spring boot·后端·sql
uzong6 小时前
技术故障复盘模版
后端
GetcharZp6 小时前
基于 Dify + 通义千问的多模态大模型 搭建发票识别 Agent
后端·llm·agent
桦说编程6 小时前
Java 中如何创建不可变类型
java·后端·函数式编程
IT毕设实战小研6 小时前
基于Spring Boot 4s店车辆管理系统 租车管理系统 停车位管理系统 智慧车辆管理系统
java·开发语言·spring boot·后端·spring·毕业设计·课程设计
wyiyiyi7 小时前
【Web后端】Django、flask及其场景——以构建系统原型为例
前端·数据库·后端·python·django·flask
apocelipes8 小时前
下划线字段在golang结构体中的应用
golang
阿华的代码王国8 小时前
【Android】RecyclerView复用CheckBox的异常状态
android·xml·java·前端·后端
Jimmy8 小时前
AI 代理是什么，其有助于我们实现更智能编程
前端·后端·ai编程
热门推荐
01UV安装并设置国内源02KGG转MP3工具|非KGM文件|解密音频03【2025.08.06最新版】Android Studio下载、安装及配置记录（自动下载sdk）04Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code05蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接062025最新国内服务器可用docker源仓库地址大全（2025年8月更新）07TRAE 规则（Rules）配置指南：个人习惯、团队规范与最佳实践08NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南09全球最强模型Grok4，国内已可免费使用！（附教程）10TRAE Rules 实践：为项目配置 6A 工作流