go基础之并发

go并发非常简单，就是使用关键字go添加到任意一个函数前面，该函数就会成为一个goroutine。

登录后复制

      
      

       
       package 
       
       main
       
       

       
       

       
       import (
       
       
    
       
       "fmt"
       
       
    
       
       "time"
       
       
)
       
       

       
       

       
       func 
       
       print() {
       
       
    
       
       arr :
       
       = [
       
       10]
       
       int{
       
       1, 
       
       2, 
       
       3, 
       
       4, 
       
       5, 
       
       6, 
       
       7, 
       
       8, 
       
       9, 
       
       10}
       
       
    
       
       for 
       
       _, 
       
       i :
       
       = 
       
       range 
       
       arr {
       
       
        
       
       fmt
       
       .
       
       Println(
       
       i)
       
       
    }
       
       
}
       
       

       
       

       
       func 
       
       main() {
       
       
    
       
       go 
       
       print()
       
       
    
       
       go 
       
       print()
       
       
    
       
       time
       
       .
       
       Sleep(
       
       5 
       
       * 
       
       time
       
       .
       
       Second)
       
       
}
      
      
      
      

       
       
1.
       
       
2.
       
       
3.
       
       
4.
       
       
5.
       
       
6.
       
       
7.
       
       
8.
       
       
9.
       
       
10.
       
       
11.
       
       
12.
       
       
13.
       
       
14.
       
       
15.
       
       
16.
       
       
17.
       
       
18.
       
       
19.
      
      

最后time.Sleep(5 * time.Second)是为了阻止还没有执行完print()就结束程序，要不会还没有打印程序就结束了。

根据输出都是从0-10，好像并发没有什么作用，主要是print函数太快，所以看不出有什么区别。把print函数加些延迟效果就出来了

登录后复制

      
      

       
       func 
       
       print() {
       
       
    
       
       arr :
       
       = [
       
       10]
       
       int{
       
       1, 
       
       2, 
       
       3, 
       
       4, 
       
       5, 
       
       6, 
       
       7, 
       
       8, 
       
       9, 
       
       10}
       
       
    
       
       for 
       
       _, 
       
       i :
       
       = 
       
       range 
       
       arr {
       
       
        
       
       time
       
       .
       
       Sleep(
       
       1 
       
       * 
       
       time
       
       .
       
       Microsecond)
       
       
        
       
       fmt
       
       .
       
       Println(
       
       i)
       
       
    }
       
       
}
      
      
      
      

       
       
1.
       
       
2.
       
       
3.
       
       
4.
       
       
5.
       
       
6.
       
       
7.
      
      

假如有这么一个需求，在2次print函数之后，还有个函数名字叫call()，这个call()函数需要在2次print函数执行后才能执行，这样如何写呢？

go语言sync包中提供了一个名叫等待组的机制，使用Add方法设置等待组的计数器，使用Done方法对等待组的计数器减1，调用Wait方法会一直阻塞，直到计数器为0才往后执行。

登录后复制

      
      

       
       var 
       
       wg 
       
       sync
       
       .
       
       WaitGroup
       
       

       
       

       
       func 
       
       print() {
       
       
    
       
       arr :
       
       = [
       
       10]
       
       int{
       
       1, 
       
       2, 
       
       3, 
       
       4, 
       
       5, 
       
       6, 
       
       7, 
       
       8, 
       
       9, 
       
       10}
       
       
    
       
       for 
       
       _, 
       
       i :
       
       = 
       
       range 
       
       arr {
       
       
        
       
       time
       
       .
       
       Sleep(
       
       1 
       
       * 
       
       time
       
       .
       
       Microsecond)
       
       
        
       
       fmt
       
       .
       
       Println(
       
       i)
       
       
    }
       
       
    
       
       wg
       
       .
       
       Done()
       
       
}
       
       

       
       

       
       func 
       
       call() {
       
       
    
       
       fmt
       
       .
       
       Println(
       
       "call")
       
       
}
       
       

       
       func 
       
       main() {
       
       
    
       
       wg
       
       .
       
       Add(
       
       2)
       
       
    
       
       go 
       
       print()
       
       
    
       
       go 
       
       print()
       
       
    
       
       wg
       
       .
       
       Wait()
       
       
    
       
       call()
       
       
}
      
      
      
      

       
       
1.
       
       
2.
       
       
3.
       
       
4.
       
       
5.
       
       
6.
       
       
7.
       
       
8.
       
       
9.
       
       
10.
       
       
11.
       
       
12.
       
       
13.
       
       
14.
       
       
15.
       
       
16.
       
       
17.
       
       
18.
       
       
19.
       
       
20.
       
       
21.
      
      

通过wg.Add(2)设置计数器为2，每次执行完print时，通过wg.Done()使计数器减1,wg.Wait()进行阻塞，2个print函数执行完，计数器变为0，往后执行call()。这样最后的一个等待时间就不再需要了。