go语言 并发场景 golang并发编程

目录

• Golang - 并发编程

• 1. 并行和并发
• 2. go语言并发优势
• 3. goroutine是什么
• 4. 创建goroutine
• 5. runtime包
• 6. channel是什么
• 7. channel的基本使用
• 8. 无缓冲的channel
• 9. 有缓冲的channel
• 10. close()
• 11. 单方向的channel
• 12. 定时器
• 13. select
• 14. 携程同步锁

Golang - 并发编程

1. 并行和并发

• 并行：在同一时刻，有多条指令在多个CPU处理器上同时执行
• 2个队伍，2个窗口，要求硬件支持
• 并发：在同一时刻，只能有一条指令执行，但多个进程指令被快速地轮换执行
• 2个队伍，1个窗口，要求提升软件能力

2. go语言并发优势

• go从语言层面就支持了并发
• 简化了并发程序的编写

3. goroutine是什么

• 它是go并发设计的核心
• goroutine就是协程，它比线程更小，十几个goroutine在底层可能就是五六个线程
• go语言内部实现了goroutine的内存共享，执行goroutine只需极少的栈内存(大概是4~5KB)

4. 创建goroutine

• 只需要在语句前添加go关键字，就可以创建并发执行单元
  package main
  import (
  "fmt"
  "time"
  )
  //测试协程
  //循环打印内容
  func newTask() {
  i := 0
  for {
  i++
  fmt.Printf("new goroutine:i=%d\n", i)
  time.Sleep(1 * time.Second)
  }
  }
  //main()相当于是主协程
  func main() {
  //启动子协程
  go newTask()
  i := 0
  for {
  i++
  fmt.Printf("main goroutine:i=%d\n", i)
  time.Sleep(1 * time.Second)
  }
  }
• 开发⼈员无需了解任何执⾏细节，调度器会自动将其安排到合适的系统线程上执行
• 如果主协程退出了，其他任务还执行吗？不执行

package main
  
  import (
     "fmt"
     "time"
  )
  
  //main()相当于是主协程
  func main() {
     //匿名子协程
     go func() {
        i := 0
        for {
           i++
           fmt.Println("子协程 i=", i)
           time.Sleep(1 * time.Second)
        }
     }()
     i := 0
     for {
        i++
        fmt.Println("主协程 i=", i)
        time.Sleep(1 * time.Second)
        //主协程第二次后退出
        if i == 2 {
           break
        }
     }
  }

• 程序没任何输出，也不报错

package main
  
  import (
     "fmt"
     "time"
  )
  
  //main()相当于是主协程
  func main() {
     //匿名子协程
     go func() {
        i := 0
        for {
           i++
           fmt.Println("子协程 i=", i)
           time.Sleep(1 * time.Second)
        }
     }()
  }

5. runtime包

• runtime.Gosched()：用于让出CPU时间片，调度器重新安排任务调度，还是有几率分配到它的

package main
  
  import (
     "fmt"
     "runtime"
  )
  
  func main() {
     //匿名子协程
     go func(s string) {
        for i := 0; i < 2; i++ {
           fmt.Println(s)
        }
     }("world")
     //主协程
     for i := 0; i < 2; i++ {
        runtime.Gosched()
        fmt.Println("hello")
     }
  }

• runtime.Goexit()：立即终止当前协程

package main
  
  import (
     "fmt"
     "time"
     "runtime"
  )
  
  func main() {
     //匿名子协程
     go func() {
        defer fmt.Println("A.defer")
        //匿名函数
        func() {
           defer fmt.Println("B.defer")
           //此时只有defer执行
           runtime.Goexit()
           fmt.Println("B")
        }()
        fmt.Println("A")
     }()
     for {
        time.Sleep(time.Second)
     }
  }

• runtime.GOMAXPROCS()：设置并行计算的CPU核数，返回之前的值

package main
  
  import (
     "runtime"
     "fmt"
  )
  
  func main() {
     n := runtime.GOMAXPROCS(3)
     fmt.Println("n=%d\n",n)
     //循环执行2个
     for{
        go fmt.Print(0)
        fmt.Print(1)
     }
  }

6. channel是什么

• goroutine运行在相同的地址空间，因此访问共享内存必须做好同步，处理好线程安全问题
• goroutine奉行通过通信来共享内存，而不是共享内存来通信
• channel是一个引用类型，用于多个goroutine通讯，其内部实现了同步，确保并发安全

7. channel的基本使用

• channel可以用内置make()函数创建
• 定义一个channel时，也需要定义发送到channel的值的类型

make(chan 类型)   //无缓冲的通道
  make(chan 类型, 容量) //有缓冲的通道

• 当 capacity= 0 时，channel 是无缓冲阻塞读写的，当capacity> 0 时，channel 有缓冲、是非阻塞的，直到写满 capacity个元素才阻塞写入
• channel通过操作符<-来接收和发送数据，发送和接收数据语法：

channel <- value   //发送value到channel
  <-channel          //接收通道数据，并丢弃
  x := <-channel    //通道取值并赋给x
  x, ok := <-channel //ok是检查通道是否关闭或者是否为空

• channel基本使用

package main
  
  import "fmt"
  
  func main() {
     //创建存放int类型的通道
     c := make(chan int)
     //子协程
     go func() {
        defer fmt.Println("子协程结束")
        fmt.Println("子协程正在运行...")
        //将666发送到通道c
        c <- 666
     }()
     //若已取出数据，下面再取会报错
     //<-c
     //主协程取数据
     //从c中取数据
     num := <-c
     fmt.Println("num = ", num)
     fmt.Println("主协程结束")
  }

8. 无缓冲的channel

• 无缓冲的通道是指在接收前没有能力保存任何值的通道
• 无缓冲通道，有可能阻塞

发送者 -> (通道(有可能有数据阻塞)) -> 接受者

package main

import (
   "fmt"
   "time"
)

func main() {
   //创建无缓冲通道
   c := make(chan int, 0)
   //长度和容量
   fmt.Printf("len(c)=%d, cap(c)=%d\n", len(c), cap(c))
   //子协程存数据
   go func() {
      defer fmt.Println("子协程结束")
      //向通道添加数据
      for i := 0; i < 3; i++ {
         c <- i
         fmt.Printf("子协程正在运行[%d]:len(c)=%d,cap(c)=%d\n", i, len(c), cap(c))
      }
   }()

   time.Sleep(2 * time.Second)
   //主协程取数据
   for i := 0; i < 3; i++ {
      num := <-c
      fmt.Println("num=", num)
   }
   fmt.Println("主协程结束")
}

9. 有缓冲的channel

• 有缓冲的通道是一种在被接收前能存储一个或者多个值的通道

发送者 -> (通道(数据),(数据)(...)) -> 接受者

• 上面代码创建时修改容量即可

//创建有缓存的通道
  c :=make(chan int, 3)

10. close()

• 可以通过内置的close()函数关闭channel

package main
  
  import "fmt"
  
  func main() {
     //创建通道
     c := make(chan int)
     //子协程存数据
     go func() {
        for i := 0; i < 5; i++ {
           c <- i
        }
        //子协程close
        close(c)
     }()
     //主协程取数据
     for {
        if data, ok := <-c; ok {
           fmt.Println(data)
        } else {
           break
        }
     }
     fmt.Println("Finshed")
  }

• 也可以如下遍历

for data := range c{
  	fnt.Println(data)
  }

11. 单方向的channel

• 默认情况下，通道是双向的，也就是，既可以往里面发送数据也可以接收数据
• go可以定义单方向的通道，也就是只发送数据或者只接收数据，声明如下
  var ch1 chan int //正常的
  var ch2 chan<- float64 //单向的，只用于写float64的数据
  var ch3 <-chan int //单向的，只用于读取int数据
• 可以将 channel 隐式转换为单向队列，只收或只发，不能将单向 channel 转换为普通channel

func main() {
//创建通道
c := make(chan int, 3)

//1. 将c准换为只写的通道
var send <- chan int =c

//2. 将c转为只读的通道
var recv <- chan int =c

//往send里面写数据
send < -1

//从recv读数据
<-recv

}

• 单方向的channel有什么用？模拟生产者和消费者

package main
  
  import "fmt"
  
  //生产者，只写
  func producter(out chan<- int) {
     //关闭资源
     defer close(out)
     for i := 0; i < 5; i++ {
        out <- i
     }
  }
  
  //消费者，只读
  func consumer(in <-chan int) {
     for num := range in {
        fmt.Println(num)
     }
  }
  
  func main() {
     //创建通道
     c := make(chan int)
     //生产者运行，向管道c存数据
     go producter(c)
     //消费者运行
     consumer(c)
     fmt.Println("done")
  }

12. 定时器

• Timer：定时，时间到了响应一次

package main
  
  import (
     "time"
     "fmt"
  )
  
  func main() {
     //1.基本使用
     //创建定时器
     //2秒后，定时器会将一个时间类型值，保存向自己的c
     //timer1 := time.NewTimer(2 * time.Second)
     ////打印当前时间
     //t1 := time.Now()
     //fmt.Printf("t1:%v\n", t1)
     ////从管道中取出C打印
     //t2 := <-timer1.C
     //fmt.Printf("t2:%v\n", t2)
  
     //2.Timer只响应一次
     //timer2 := time.NewTimer(time.Second)
     //for {
     // <-timer2.C
     // fmt.Println("时间到")
     //}
  
     //3.通过Timer实现延时的功能
     ////(1)睡眠
     //time.Sleep(2*time.Second)
     //fmt.Println("2秒时间到")
     ////(2)通过定时器
     //timer3 := time.NewTimer(2 * time.Second)
     //<-timer3.C
     //fmt.Println("2秒时间到")
     ////(3)After()
     //<-time.After(2 * time.Second)
     //fmt.Println("2秒时间到")
  
     //4.停止定时器
     //timer4 := time.NewTimer(3 * time.Second)
     ////子协程
     //go func() {
     // <-timer4.C
     // fmt.Println("定时器器时间到，可以打印了")
     //}()
     //stop := timer4.Stop()
     //if stop {
     // fmt.Println("timer4已关闭")
     //}
  
     //5.重置定时器
     timer5 := time.NewTimer(3 * time.Second)
     //定时器改为1秒
     timer5.Reset(1 * time.Second)
     fmt.Println(time.Now())
     fmt.Println(<-timer5.C)
  
     for {
     }
  }

• Ticker：响应多次
  package main
  import (
  "time"
  "fmt"
  )
  func main() {
  //创建定时器，间隔1秒
  ticker := time.NewTicker(time.Second)

i := 0
 //子协程
 go func() {
    for {
       <-ticker.C
       fmt.Println(<-ticker.C)
       i++
       fmt.Println("i=", i)
       //停止定时器
       if i == 5 {
          ticker.Stop()
       }
    }
 }()

 //死循环
 for {

 }

}

13. select

• go语言提供了select关键字，可以监听channel上的数据流动
• 语法与switch类似，区别是select要求每个case语句里必须是一个IO操作

select {
  case <-chan1:
     // 如果chan1成功读到数据，则进行该case处理语句
  case chan2 <- 1:
     // 如果成功向chan2写入数据，则进行该case处理语句
  default:
     // 如果上面都没有成功，则进入default处理流程
  }
  
  package main
  
  import (
     "fmt"
  )
  
  func main() {
     //创建数据通道
     int_chan := make(chan int, 1)
     string_chan := make(chan string, 1)
     //创建2个子协程，写数据
     go func() {
        //time.Sleep(2 * time.Second)
        int_chan <- 1
     }()
     go func() {
        string_chan <- "hello"
     }()
     //如果都能匹配到，则随机选择一个去跑
     select {
     case value := <-int_chan:
        fmt.Println("intValue:", value)
     case value := <-string_chan:
        fmt.Println("strValue:", value)
     }
     fmt.Println("finish")
  }

14. 携程同步锁

• go中channel实现了同步，确保并发安全，同时也提供了锁的操作方式
• go中sync包提供了锁相关的支持
• Mutex：以加锁方式解决并发安全问题

package main
  
  import (
     "time"
     "fmt"
     "sync"
  )
  
  //账户
  type Account struct {
     money int
     flag sync.Mutex
  }
  
  //模拟银行检测
  func (a *Account)Check()  {
     time.Sleep(time.Second)
  }
  
  //设置账户余额
  func (a *Account)SetAccount(n int)  {
     a.money +=n
  }
  
  //查询账户余额
  func (a *Account)GetAccount() int{
     return a.money
  }
  
  //买东西1
  func (a *Account)Buy1(n int){
     a.flag.Lock()
     if a.money>n{
        //银行检测
        a.Check()
        a.money -=n
     }
     a.flag.Unlock()
  }
  
  //买东西2
  func (a *Account)Buy2(n int){
     a.flag.Lock()
     if a.money>n{
        //银行检测
        a.Check()
        a.money -=n
     }
     a.flag.Unlock()
  }
  
  func main() {
     var account Account
     //设置账户余额
     account.SetAccount(10)
     //2个子协程买东西
     go account.Buy1(6)
     go account.Buy2(5)
     time.Sleep(2 * time.Second)
     fmt.Println(account.GetAccount())
  }

• sync.WaitGroup：用来等待一组子协程的结束，需要设置等待的个数，每个子协程结束后要调用Done()，最后在主协程中Wait()即可
• 引入

package main
  
  import (
     "fmt"
  )
  
  func main() {
     //创建通道
     ch := make(chan int)
     //count表示活动的协程个数
     count := 2
     go func() {
        fmt.Println("子协程1")
        //子协程1执行完成，给通道发送信号
        ch <-1
     }()
     go func() {
        fmt.Println("子协程2")
        ch <-1
     }()
     //time.Sleep(time.Second)
     //从ch中不断读数据
     for range ch{
        count --
        if count == 0{
           close(ch)
        }
     }
  }

• go提供了这种解决方案sync.WaitGroup
• Add()：添加计数
• Done()：操作结束时调用，计数减去1
• Wait()：主函数调用，等待所有操作结束

---

未完待续...