在 Go 1.23 中，Timer 的实现通常是通过 time 包提供的 time.Timer 类型来实现的。Timer 是一个用于在指定时间后触发一次事件的计时器。Timer 的实现并不依赖于缓冲区，而是通过 Go 的调度器和通道机制来实现的。

Timer 的基本实现

Timer 的核心是一个 time.Timer 结构体，它包含一个 time.Timer.C 通道，当计时器到期时，当前时间会被发送到这个通道。
以下是一个简单的 Timer 实现示例：

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "time"
   
6. )
   
7. 
   
8. func main() {
   
9.         // 创建一个 Timer，设置 2 秒后触发
   
10.         timer := time.NewTimer(2 * time.Second)
    
11. 
    
12.         // 等待 Timer 触发
    
13.         <-timer.C
    
14.         fmt.Println("Timer expired")
    
15. 
    
16.         // 如果你想要停止 Timer，可以使用 Stop() 方法
    
17.         // timer.Stop()
    
18. }

复制代码

无缓冲区的实现

Timer 的实现并不依赖于缓冲区，而是通过 Go 的通道机制来实现的。Timer.C 是一个无缓冲的通道，当计时器到期时，当前时间会被发送到这个通道。由于通道是无缓冲的，发送操作会阻塞，直到有接收者准备好接收数据。

自定义无缓冲 Timer 实现

如果你想自己实现一个无缓冲的 Timer，可以使用 time.After 函数，它返回一个通道，当指定的时间到达时，通道会接收到一个时间值。

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "time"
   
6. )
   
7. 
   
8. func main() {
   
9.         // 使用 time.After 创建一个无缓冲的 Timer
   
10.         timerCh := time.After(2 * time.Second)
    
11. 
    
12.         // 等待 Timer 触发
    
13.         <-timerCh
    
14.         fmt.Println("Timer expired")
    
15. }

复制代码

更复杂的 Timer 实现

如果你需要更复杂的 Timer 实现，比如可以重置或停止的 Timer，可以参考以下代码：

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "time"
   
6. )
   
7. 
   
8. type MyTimer struct {
   
9.         duration time.Duration
   
10.         timer    *time.Timer
    
11.         resetCh  chan time.Duration
    
12.         stopCh   chan struct{}
    
13. }
    
14. 
    
15. func NewMyTimer(duration time.Duration) *MyTimer {
    
16.         t := &MyTimer{
    
17.                 duration: duration,
    
18.                 resetCh:  make(chan time.Duration),
    
19.                 stopCh:   make(chan struct{}),
    
20.         }
    
21.         t.timer = time.NewTimer(duration)
    
22.         go t.run()
    
23.         return t
    
24. }
    
25. 
    
26. func (t *MyTimer) run() {
    
27.         for {
    
28.                 select {
    
29.                 case <-t.timer.C:
    
30.                         fmt.Println("Timer expired")
    
31.                         return
    
32.                 case newDuration := <-t.resetCh:
    
33.                         if !t.timer.Stop() {
    
34.                                 <-t.timer.C
    
35.                         }
    
36.                         t.timer.Reset(newDuration)
    
37.                 case <-t.stopCh:
    
38.                         if !t.timer.Stop() {
    
39.                                 <-t.timer.C
    
40.                         }
    
41.                         return
    
42.                 }
    
43.         }
    
44. }
    
45. 
    
46. func (t *MyTimer) Reset(duration time.Duration) {
    
47.         t.resetCh <- duration
    
48. }
    
49. 
    
50. func (t *MyTimer) Stop() {
    
51.         t.stopCh <- struct{}{}
    
52. }
    
53. 
    
54. func main() {
    
55.         timer := NewMyTimer(2 * time.Second)
    
56. 
    
57.         time.Sleep(1 * time.Second)
    
58.         timer.Reset(3 * time.Second)
    
59. 
    
60.         time.Sleep(2 * time.Second)
    
61.         timer.Stop()
    
62.         fmt.Println("Timer stopped")
    
63. }

复制代码

在这个示例中，MyTimer 是一个自定义的 Timer 实现，它支持重置和停止操作。MyTimer 使用 time.Timer 作为底层实现，并通过通道来接收重置和停止的信号。

总结

Go 中的 Timer 实现依赖于无缓冲的通道和 Go 的调度器。你可以使用 time.Timer 或 time.After 来创建简单的 Timer，或者通过自定义结构体来实现更复杂的 Timer 功能。
到此这篇关于Go 1.23中Timer无buffer的实现方式详解的文章就介绍到这了,更多相关Go实现Timer无buffer内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：互联网
免责声明：如果侵犯了您的权益，请联系站长（1277306191@qq.com），我们会及时删除侵权内容，谢谢合作！