TickerOrSleep？定时执行的新选择

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

分享题目：TickerOrSleep？定时执行的新选择
链接分享：http://www.csdahua.cn/qtweb/news3/212003.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

服务器托管知识

同城分类信息

微信小程序公众号开发　　 　成都小程序开发　　 　app软件开发　　 　成都小程序开发　　 　乐山服务器托管　　 　成都网站设计　　 　成都全网营销推广　　 　成都枢纽中心　　 　成都seo优化　　 　LED网站设计方案　　 　成都网站维护　　 　做手机网站　　 　高端品牌网站建设　　 　成都手机网站开发　　 　简阳电信机房　　 　成都雨棚定制　　 　温江服务器托管　　 　成都标志设计　　 　网站建设方案　　 　营销型网站