个人中心
gpt4 book ai didi

golang time包下定时器的实现方法

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 24 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章golang time包下定时器的实现方法由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

golang time包 。

和python一样,golang时间处理还是比较方便的，以下介绍了golang 时间日期，相关包 "time"的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍.

时间戳 。

当前时间戳 。

?
1
2
fmt.Println(time.Now().Unix())
# 1389058332

str格式化时间 。

当前格式化时间 。

?
1
2
fmt.Println(time.Now(). Format ( "2006-01-02 15:04:05" )) / / 这是个奇葩,必须是这个时间点, 据说是go诞生之日, 记忆方法: 6 - 1 - 2 - 3 - 4 - 5
# 2014-01-07 09:42:20

时间戳转str格式化时间 。

?
1
2
3
str_time : = time.Unix( 1389058332 , 0 ). Format ( "2006-01-02 15:04:05" )
fmt.Println(str_time)
# 2014-01-07 09:32:12

str格式化时间转时间戳 。

这个比较麻烦 。

?
1
2
3
4
the_time := time.Date(2014, 1, 7, 5, 50, 4, 0, time.Local)
unix_time := the_time.Unix()
fmt.Println(unix_time)
# 389045004

还有一种方法,使用time.Parse 。

?
1
2
3
4
5
6
the_time, err := time.Parse("2006-01-02 15:04:05", "2014-01-08 09:04:41")
if err == nil {
unix_time := the_time.Unix()
fmt.Println(unix_time)
}
# 1389171881

以上简单介绍了golang中time包的相关内容，下面开始本文的正文.

引言 。

这篇文章简单的介绍下golang time 包下定时器的实现，说道定时器，在我们开发过程中很常用，由于使用的场景不同，所以对定时器实际的实现也就不同，go的定时器并没有使用SIGALARM信号实现，而是采取最小堆的方式实现(源码包中使用数组实现的四叉树)，使用这种方式定时精度很高，但是有的时候可能我们不需要这么高精度的实现，为了更高效的利用资源，有的时候也会实现一个精度比较低的算法.

跟golang定时器相关的入口主要有以下几种方法:

?
1
2
3
4
5
6
<-time.Tick(time.Second)
<-time.After(time.Second)
<-time.NewTicker(time.Second).C
<-time.NewTimer(time.Second).C
time.AfterFunc(time.Second, func() { /*do*/ })
time.Sleep(time.Second)

这里我们以其中NewTicker为入口，NewTicker的源码如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
func NewTicker(d Duration) *Ticker {
  if d <= 0 {
  panic(errors.New("non-positive interval for NewTicker"))
  }
  c := make(chan Time, 1)
  t := &Ticker{
  C: c,
  r: runtimeTimer{
  // when(d)返回一个runtimeNano() + int64(d)的未来时(到期时间)
  //runtimeNano运行时当前纳秒时间
  when: when(d),
  period: int64(d), // 被唤醒的时间
  f:  sendTime, // 时间到期后的回调函数
  arg: c,  // 时间到期后的断言参数
  },
  }
  // 将新的定时任务添加到时间堆中
  // 编译器会将这个函数翻译为runtime.startTimer(t *runtime.timer)
  // time.runtimeTimer翻译为runtime.timer
  startTimer(&t.r)
  return t

这里有个比较重要的是startTimer(&t.r)它的实现被翻译在runtime包内 。

?
1
2
3
4
5
6
7
8
9
10
11
12
func startTimer(t *timer) {
  if raceenabled {
  racerelease(unsafe.Pointer(t))
  }
  addtimer(t)
}
 
func addtimer(t *timer) {
  lock(&timers.lock)
  addtimerLocked(t)
  unlock(&timers.lock)
}

上面的代码为了看着方便，我将他们都放在一起 。

下面代码都写出部分注释 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
// 使用锁将计时器添加到堆中
// 如果是第一次运行此方法则启动timerproc
func addtimerLocked(t *timer) {
  if t.when < 0 {
  t.when = 1<<63 - 1
  }
  // t.i i是定时任务数组中的索引
  // 将新的定时任务追加到定时任务数组队尾
  t.i = len(timers.t)
  timers.t = append(timers.t, t)
  // 使用数组实现的四叉树最小堆根据when(到期时间)进行排序
  siftupTimer(t.i)
  // 如果t.i 索引为0
  if t.i == 0 {
  if timers.sleeping {
  // 如果还在sleep就唤醒
  timers.sleeping = false
  // 这里基于OS的同步，并进行OS系统调用
  // 在timerproc()使goroutine从睡眠状态恢复
  notewakeup(&timers.waitnote)
  }
  if timers.rescheduling {
  timers.rescheduling = false
  // 如果没有定时器，timerproc()与goparkunlock共同sleep
  // goready这里特殊说明下，在线程创建的堆栈，它比goroutine堆栈大。
  // 函数不能增长堆栈，同时不能被调度器抢占
  goready(timers.gp, 0)
  }
  }
  if !timers.created {
  timers.created = true
  go timerproc() //这里只有初始化一次
  }
}
 
// Timerproc运行时间驱动的事件。
// 它sleep到计时器堆中的下一个。
// 如果addtimer插入一个新的事件，它会提前唤醒timerproc。
func timerproc() {
  timers.gp = getg()
  for {
  lock(&timers.lock)
  timers.sleeping = false
  now := nanotime()
  delta := int64(-1)
  for {
  if len(timers.t) == 0 {
  delta = -1
  break
  }
  t := timers.t[0]
  delta = t.when - now
  if delta > 0 {
  break // 时间未到
  }
  if t.period > 0 {
  // 计算下一次时间
         // period被唤醒的间隔
  t.when += t.period * (1 + -delta/t.period)
  siftdownTimer(0)
  } else {
  // remove from heap
  last := len(timers.t) - 1
  if last > 0 {
   timers.t[0] = timers.t[last]
   timers.t[0].i = 0
  }
  timers.t[last] = nil
  timers.t = timers.t[:last]
  if last > 0 {
   siftdownTimer(0)
  }
  t.i = -1 // 标记移除
  }
  f := t.f
  arg := t.arg
  seq := t.seq
  unlock(&timers.lock)
  if raceenabled {
  raceacquire(unsafe.Pointer(t))
  }
  f(arg, seq)
  lock(&timers.lock)
  }
  if delta < 0 || faketime > 0 {
  // 没有定时器，把goroutine sleep。
  timers.rescheduling = true
  // 将当前的goroutine放入等待状态并解锁锁。
  // goroutine也可以通过呼叫goready(gp)来重新运行。
  goparkunlock(&timers.lock, "timer goroutine (idle)", traceEvGoBlock, 1)
  continue
  }
  // At least one timer pending. Sleep until then.
  timers.sleeping = true
  timers.sleepUntil = now + delta
  // 重置
  noteclear(&timers.waitnote)
  unlock(&timers.lock)
  // 使goroutine进入睡眠状态，直到notewakeup被调用，
  // 通过notewakeup 唤醒
  notetsleepg(&timers.waitnote, delta)
  }
}

golang使用最小堆(最小堆是满足除了根节点以外的每个节点都不小于其父节点的堆)实现的定时器。golang []*timer结构如下

golang time包下定时器的实现方法

golang存储定时任务结构 。

addtimer在堆中插入一个值，然后保持最小堆的特性，其实这个结构本质就是最小优先队列的一个应用，然后将时间转换一个绝对时间处理，通过睡眠和唤醒找出定时任务，这里阅读起来源码很容易，所以只将代码和部分注释写出.

总结 。

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对我的支持.

原文链接：https://zhuanlan.zhihu.com/p/31634188 。

最后此篇关于golang time包下定时器的实现方法的文章就讲到这里了,如果你想了解更多关于golang time包下定时器的实现方法的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

24 4 0
文章推荐： golang新手不注意可能会出现的一些小问题
文章推荐： Go语言中一些不常见的命令参数详解
文章推荐： Go语言中你所不知道的位操作用法
文章推荐： Go语言每天必学之switch语句
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com