一篇学会Go并发等待

上节答疑

上一节有读者问goroutine stack size一般是多大，我进行了详细的查询

创新互联建站是专业的阿拉山口网站建设公司，阿拉山口接单;提供网站设计、做网站,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行阿拉山口网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

关于 goroutine stack size(栈内存大小) 官方的文档 中所述，1.2 之前最小是4kb，在1.2 变成8kb，并且可以使用SetMaxStack 设置栈最大大小。

在 runtime/debug 包能控制最大的单个 goroutine 的堆栈的大小。在 64 位系统上默认为 1GB，在 32 位系统上默认为 250MB。

因为每个goroutine需要能够运行，所以它们都有自己的栈。假如每个goroutine分配固定栈大小并且不能增长，太小则会导致溢出，太大又会浪费空间，无法存在许多的goroutine。

所以在1.3版本中，改为了 Contiguous stack( 连续栈 )，为了解决这个问题，goroutine可以初始时只给栈分配很小的空间(8KB)，然后随着使用过程中的需要自动地增长。这就是为什么Go可以开千千万万个goroutine而不会耗尽内存。

1.4 版本 goroutine 堆栈从 8Kb 减少到 2Kb

Golang并发等待

本节源码位置 https://github.com/golang-minibear2333/golang/blob/master/4.concurrent/goroutine-wait/”

简介

goroutine 是 Golang 中非常有用的功能，有时候 goroutine 没执行完函数就返回了，如果希望等待当前的 goroutine 执行完成再接着往下执行，该怎么办?

 
 
 
    
  
  
  
  1. func say(s string) { 
    2.   
  
  
  2.     for i := 0; i < 3; i++ { 
    3.   
  
  
  3.         time.Sleep(100 * time.Millisecond) 
    4.   
  
  
  4.         fmt.Println(s) 
    5.   
  
  
  5.     } 
    6.   
  
  
  6. } 
    7.   
  
  
  7.  
    8.   
  
  
  8. func main() { 
    9.   
  
  
  9.     go say("hello world") 
    10.   
  
  
  10.     fmt.Println("over!") 
    11.   
  
  
  11. } 
    12.

输出 over! , 主线程没有等待

使用 Sleep 等待

 
 
 
    
  
  
  
  1. func main() { 
    2.   
  
  
  2.     go say("hello world") 
    3.   
  
  
  3.     time.Sleep(time.Second*1) 
    4.   
  
  
  4.     fmt.Println("over!") 
    5.   
  
  
  5. } 
    6.

运行修改后的程序，结果如下：

 
 
 
    
  
  
  
  1. hello world 
    2.   
  
  
  2. hello world 
    3.   
  
  
  3. hello world 
    4.   
  
  
  4. over! 
    5.

结果符合预期，但是太 low 了，我们不知道实际执行中应该等待多长时间，所以不能接受这个方案!

发送信号

 
 
 
    
  
  
  
  1. func main() { 
    2.   
  
  
  2.     done := make(chan bool) 
    3.   
  
  
  3.     go func() { 
    4.   
  
  
  4.         for i := 0; i < 3; i++ { 
    5.   
  
  
  5.             time.Sleep(100 * time.Millisecond) 
    6.   
  
  
  6.             fmt.Println("hello world") 
    7.   
  
  
  7.         } 
    8.   
  
  
  8.         done <- true 
    9.   
  
  
  9.     }() 
    10.   
  
  
  10.  
    11.   
  
  
  11.     <-done 
    12.   
  
  
  12.     fmt.Println("over!") 
    13.   
  
  
  13. } 
    14.

输出的结果和上面相同，也符合预期

这种方式不能处理多个协程，所以也不是优雅的解决方式。

WaitGroup

Golang 官方在 sync 包中提供了 WaitGroup 类型可以解决这个问题。其文档描述如下：

使用方法可以总结为下面几点：

  • 在父协程中创建一个 WaitGroup 实例，比如名称为：wg
  • 调用 wg.Add(n) ，其中 n 是等待的 goroutine 的数量
  • 在每个 goroutine 运行的函数中执行 defer wg.Done()
  • 调用 wg.Wait() 阻塞主逻辑
  • 直到所有 goroutine 执行完成。
 
 
 
    
  
  
  
  1. func main() { 
    2.   
  
  
  2.     var wg sync.WaitGroup 
    3.   
  
  
  3.     wg.Add(2) 
    4.   
  
  
  4.     go say2("hello", &wg) 
    5.   
  
  
  5.     go say2("world", &wg) 
    6.   
  
  
  6.     fmt.Println("over!") 
    7.   
  
  
  7.     wg.Wait() 
    8.   
  
  
  8. } 
    9.   
  
  
  9.  
    10.   
  
  
  10. func say2(s string, waitGroup *sync.WaitGroup) { 
    11.   
  
  
  11.     defer waitGroup.Done() 
    12.   
  
  
  12.  
    13.   
  
  
  13.     for i := 0; i < 3; i++ { 
    14.   
  
  
  14.         fmt.Println(s) 
    15.   
  
  
  15.     } 
    16.   
  
  
  16. } 
    17.

输出，注意顺序混乱是因为并发执行

 
 
 
    
  
  
  
  1. hello 
    2.   
  
  
  2. hello 
    3.   
  
  
  3. hello 
    4.   
  
  
  4. over! 
    5.   
  
  
  5. world 
    6.   
  
  
  6. world 
    7.   
  
  
  7. world 
    8.

小心缺陷

简短的例子，注意循环传入的变量用中间变量替代，防止闭包 bug

 
 
 
    
  
  
  
  1. func errFunc() { 
    2.   
  
  
  2.  var wg sync.WaitGroup 
    3.   
  
  
  3.  sList := []string{"a", "b"} 
    4.   
  
  
  4.  wg.Add(len(sList)) 
    5.   
  
  
  5.  for _, d := range sList { 
    6.   
  
  
  6.   go func() { 
    7.   
  
  
  7.    defer wg.Done() 
    8.   
  
  
  8.    fmt.Println(d) 
    9.   
  
  
  9.   }() 
    10.   
  
  
  10.  } 
    11.   
  
  
  11.  wg.Wait() 
    12.   
  
  
  12. } 
    13.

输出，可以发现全部变成了最后一个

 
 
 
    
  
  
  
  1. b 
    2.   
  
  
  2. b 
    3.

父协程与子协程是并发的。父协程上的for循环瞬间执行完了，内部的协程使用的是d最后的值，这就是闭包问题。

解决方法当作参数传入

 
 
 
    
  
  
  
  1. func correctFunc() { 
    2.   
  
  
  2.  var wg sync.WaitGroup 
    3.   
  
  
  3.  sList := []string{"a", "b"} 
    4.   
  
  
  4.  wg.Add(len(sList)) 
    5.   
  
  
  5.  for _, d := range sList { 
    6.   
  
  
  6.   go func(str string) { 
    7.   
  
  
  7.    defer wg.Done() 
    8.   
  
  
  8.    fmt.Println(str) 
    9.   
  
  
  9.   }(d) 
    10.   
  
  
  10.  } 
    11.   
  
  
  11.  wg.Wait() 
    12.   
  
  
  12. } 
    13.

输出

 
 
 
    
  
  
  
  1. b 
    2.   
  
  
  2. a 
    3.

要留意 range 中的value有可能出现 1.7.3 有可能会遇到的坑!

网站题目：一篇学会Go并发等待
URL标题：http://www.shufengxianlan.com/qtweb/news21/553171.html

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

广告

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

猜你还喜欢下面的内容

网站排名知识

分类信息网站

什邡网站建设　　 　成都logo设计标志　　 　水泥基自流平　　 　广东帝美豪门窗　　 　高端网站建设　　 　品牌官网设计　　 　定制网站　　 　成都网站制作　　 　成都手机网站报价　　 　成都托管服务器　　 　四川服务器托管　　 　网站域名　　 　成都网站设计　　 　安防网站建设方案　　 　宣传册设计　　 　重庆网站建设网络公司　　 　led无边发光字　　 　全网整合营销推广　　 　主机租用　　 　成都网站制作