Go语言并发编程(goroutine)——并发与通信

author: histonevon@zohomail.com

date: 2020/08/04

1.关于Go语言并发

1. go程序的整个运行时都是完全并发化设计

2. 凡是你能看到的，几乎都以goroutine方式运行

3. goroutine是一种比普通协程或线程更高效的并发设计

4. 能轻松创建和运行上千万的并发任务

5. 这些goroutine将会通过go运行时而映射到适当的操作系统原语（比如，POSIX线程）

2.通过 go 函数名 实现并发

 // goroutine project main.go
 package main
 ​
 import (
     "fmt"
     "time"
 )
 ​
 //体验
 func main() {
     go task1() //使main task1 task2成为并列线程（协程）
     go task2()
     time.Sleep(time.Second * 6)
 }
 ​
 func task1() {
     for i := 0; i < 5; i++ {
         fmt.Println("这世界我来了")
         time.Sleep(time.Second)
     }
 }
 ​
 func task2() {
     for i := 0; i < 5; i++ {
         fmt.Println("任凭风暴漩涡")
         time.Sleep(time.Second)
     }
 }
 ​

• 使用Sleep函数实现等待（需要time包）

• 使用go func()开启线程（协程）

3.各并发/行体之间的通信

以生产消费模型为例

 // goroutine project main.go
 package main
 ​
 import (
     "fmt"
 )
 ​
 //并发 通道
 //生产消费模型
 //生产者
 func producer(data chan int) {
     for i := 0; i < 4; i++ {
         fmt.Println("produce：", i)
         data <- i //发送数据，向data通道写入数据
     }
     close(data) //生产结束，关闭通道
 }
 ​
 //消费者
 func consumer(data chan int, done chan bool) {
     for x := range data { //接收数据，直到通道关闭
         fmt.Println("receive:", x)
     }
     done <- true //消费结束，向done通道写入true
 }
 ​
 func main() {
     dat := make(chan int)
     stop := make(chan bool)
     go producer(dat)       //开启生产者线程
     go consumer(dat, stop) //开启消费者线程
     <-stop                 //阻塞，直到接收到消费者发出的结束信号
 }
 ​

• 创建通道：channelName:=make(chan 通道类型)

  eg. dat := make(chan int) stop := make(chan bool)

• 通道类型（做参数）：channelName chan 通道类型

  eg. data chan int done chan bool

• 向通道中写入数据：channelName<-data

例子：使用并发法求Pi

 package main
 ​
 import (
    "fmt"
    "math"
 )
 ​
 func main() {
    fmt.Println("Plz input the n of accuracy: ")
    var n int
    fmt.Scanln(&n)//用户输入精度
 ​
    ch:=make(chan float64,100)//缓冲区为100
    do:=make(chan bool)
    go producer(ch,n)//启动生产者
    go consumer(ch,do)//启动消费者
    <-do//阻塞，直到接收消费者发出的结束信号
 }
 ​
 func producer(data chan float64,n int) {
    for i:=0;i<n;i++{
       temp:=float64(i)
       data<-math.Pow(-1,temp)/(2*temp+1)//向通道中写入每一项的数据
    }
    close(data)
 }
 ​
 func consumer(data chan float64, done chan bool) {
    var f float64=0.0
    for x:=range data{
       f+=x//将data通道中的数据加到f中
    }
    fmt.Println("The estimate of Π is: ",f*4)
    done<-true//操作结束 向done通道写入true
 }

4.石头 剪刀 布

 // goroutine project main.go
 package main
 ​
 import (
     "fmt"
     "math/rand"
     "time"
 )
 ​
 //并发 石头剪刀布
 func main() {
     done := make(chan bool)
     gamer1 := make(chan int)
     gamer2 := make(chan int)
     go game(gamer1)             //玩家1
     go game(gamer2)             //玩家2
     go pk(gamer1, gamer2, done) //猜拳
     //玩家1 玩家2 猜拳三件事同时发生 同时产生结果
     <-done
 }
 ​
 func game(gamer chan int) {
     rand.Seed(time.Now().Unix()) //秒级Unix时间
     gamer <- rand.Intn(3) + 1    //向玩家通道随机写入出拳结果，123分别代表石头剪刀布
 }
 ​
 func pk(one, two chan int, done chan bool) { //两人游戏，两个int通道
     a := <-one
     b := <-two //从通道中读数据
     //进行输赢判断
     if a == b {
         fmt.Println(a, "PK", b, "equal")
     } else if a == 1 && b == 2 || a == 2 && b == 3 || a == 3 && b == 1 {
         fmt.Println(a, "PK", b, "a win")
     } else {
         fmt.Println(a, "PK", b, "b win")
     }
     done <- true
 }
 ​