当前位置：网站首页>go基础之并发

go基础之并发

2022-08-11 09:47:00 【51CTO】

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()。这样最后的一个等待时间就不再需要了。

原网站

版权声明
本文为[51CTO]所创，转载请带上原文链接，感谢
https://blog.51cto.com/u_3764469/5565708

边栏推荐

猜你喜欢

随机推荐