028-86922220
建站资讯

网站建设资讯

为你提供网站建设行业资讯、网站优化知识、主机域名邮箱、网站开发常见问题等。

TickerOrSleep?定时执行的新选择

在写 Python 的时候,如果想让某个函数每 60 秒执行一次,我们一般这样写代码:

峨眉山网站制作公司哪家好,找成都创新互联!从网页设计、网站建设、微信开发、APP开发、响应式网站建设等网站项目制作,到程序开发,运营维护。成都创新互联公司2013年成立到现在10年的时间,我们拥有了丰富的建站经验和运维经验,来保证我们的工作的顺利进行。专注于网站建设就选成都创新互联。

 
 
 
 
  1. import time 
  2.  
  3. while True: 
  4.     some_function() 
  5.     time.sleep(60) 

于是,我在写 Golang 代码的时候,也使用了这种方式:

 
 
 
 
  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "time" 
  6. ) 
  7.  
  8. func someFunction() { 
  9.     fmt.Println("我是某个函数") 
  10. } 
  11.  
  12. func main() { 
  13.     for { 
  14.         someFunction() 
  15.         time.Sleep(10 * time.Second) 
  16.     } 
  17. } 

今天在看同事的代码时,发现他是这样写的:

 
 
 
 
  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "time" 
  6. ) 
  7.  
  8. func someFunction() { 
  9.     fmt.Println("我是某个函数") 
  10. } 
  11.  
  12. func main() { 
  13.     tikcer := time.NewTicker(10 * time.Second) 
  14.     for { 
  15.         <-tikcer.C 
  16.         someFunction() 
  17.     } 
  18. } 

这种写法,初看起来时跟time.Sleep没什么区别,但是仔细一想,却发现它有很多优势。

首先,NewTicker会在背后计时,时间到了以后,会向内部的一个 channel 中推入当前的时间。然后继续计时。所以,如果函数someFunction()执行了3秒钟。那么接下来过7秒就会继续执行。但如果使用time.Sleep,函数执行完成以后,还要再等10秒钟才会执行。

其次,如果不启动新的协程,那么当执行到time.Sleep时,整个程序是卡住的,必须等待它结束了才能执行后面的操作。但如果使用 NewTicker,那么在等待的时间,还可以做很多其他的事情。多个不同的定时器可以同时工作:

 
 
 
 
  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "time" 
  6. ) 
  7.  
  8. func someFunction() { 
  9.     fmt.Println("我是某个函数") 
  10. } 
  11.  
  12. func anotherFunction() { 
  13.     fmt.Println("另一个函数") 
  14. } 
  15.  
  16. func thirdFunction() { 
  17.     fmt.Println("第三个函数") 
  18. } 
  19.  
  20. func main() { 
  21.     tikcer1 := time.NewTicker(10 * time.Second) 
  22.     tikcer2 := time.NewTicker(5 * time.Second) 
  23.     tikcer3 := time.NewTicker(3 * time.Second) 
  24.     for { 
  25.         select { 
  26.         case <-tikcer1.C: 
  27.             someFunction() 
  28.         case <-tikcer2.C: 
  29.             anotherFunction() 
  30.         case <-tikcer3.C: 
  31.             thirdFunction() 
  32.         } 
  33.     } 
  34. } 

这样可以实现,每3秒执行 thirdFunction函数,每5秒执行anotherFunction,每10秒执行一次someFunction。大家可以考虑一下,如何用 time.Sleep来实现这样的功能。

注意每个函数都是独立计时的,只要他们执行的时间不超过他们间隔的时间,就不会互相影响。

除了全部用来计时外,我们还可以用来设置外部开关,中断一个协程。例如:

 
 
 
 
  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "time" 
  6. ) 
  7.  
  8. func doSomething() { 
  9.     fmt.Println("进行某些操作") 
  10. } 
  11.  
  12. func someFunction(stop chan bool) { 
  13.     fmt.Println("我是某个函数") 
  14.     tikcer1 := time.NewTicker(10 * time.Second) 
  15.     for { 
  16.         select { 
  17.         case <-tikcer1.C: 
  18.             doSomething() 
  19.         case <-stop: 
  20.             return 
  21.         } 
  22.     } 
  23. } 
  24.  
  25. func main() { 
  26.     stop := make(chan bool) 
  27.     go someFunction(stop) 
  28.     //很多行代码 
  29.     //很多行代码 
  30.     //很多行代码 
  31.     stop <- true 
  32.     //其他代码 
  33.     //其他代码 
  34. } 

在协程里面是一个10秒执行一次的定时函数。但是我们可以在外面控制这个协程,从而随时停止这个协程。

本文转载自微信公众号「未闻Code」,可以通过以下二维码关注。转载本文请联系未闻Code公众号。


当前题目:TickerOrSleep?定时执行的新选择
网站地址:http://www.whjierui.cn/article/cdspidg.html

其他资讯