理解go与channel的关系

sync.WaitGroup

使用sync.WaitGroup等待一组并发操作完成。

var wg sync.WaitGrop
func hello(i int){
    defer wg.Done()
    fmt.Println("hello",i)
}
func main(){
    for i:=0;i<10;i++{
        wg.Add(1)
        go hello(i)
    }
    wg.Wait()  //在这里阻塞等待go结束
    fmt.Println("hello world")
}

channel 管道

通道的作用是用于两个协程之间的通信：

分类：

无缓冲channel；

有缓冲channel。

//整形无缓冲通道
unbuffered := make(chan int)
//整形有缓冲通道
buffered := make(chan int 10)

功能：

无缓存通常用于同步通信

有缓存通常用于异步通信

语法：

//整形无缓冲通道
unbuffered := make(chan int)
//整形有缓冲通道
buffered := make(chan int 10)

//无缓冲管道使用
ch1 := make(chan string)  //初始化一个无缓冲字符串管道
ch1 <- "hello world"        //发送数据到管道（在这里就阻塞了）
data :=<- ch1               //从管道接受数据
close(ch1)                  //关闭管道

//有缓冲管道使用
    //情况1：读取堵塞
  ch1 := make(chan int,5)  //大小为5的管道
  ch1 <- 10         //发送数据到管道
  ch1 <- 20       //发送数据到管道
  data :=<- ch1                     //从管道接受数据
  data2 :=<-ch1               //从管道接受数据
  data3 :=<- ch1
  fmt.Printf("data: %v\n", data)  
  fmt.Printf("data2: %v\n", data2)
  fmt.Printf("data3: %v\n", data3)  //因为管道中只有2个数据，读取第三个时会阻塞
  close(ch1)
    //情况2：发送阻塞
  ch1 := make(chan int,1)  //大小为1的管道
  ch1 <- 10         //发送数据到管道
  ch1 <- 20       //发送第二个数据到管道时会阻塞，因为管道的大小只有1
  data :=<- ch1                     //从管道接受数据
  fmt.Printf("data: %v\n", data)
  close(ch1)
    //情况三：无阻塞
  ch1 := make(chan int,5)  //字符串管道
  ch1 <- 10         //发送数据到管道
  ch1 <- 20       //发送数据到管道
  data :=<- ch1                     //从管道接受数据
  data2 :=<-ch1               //从管道接受数据
  fmt.Printf("data: %v\n", data)
  fmt.Printf("data2: %v\n", data2)
  close(ch1)

goroutine与channel

for range从channel中取值

当通道被关闭后，会在通道内的所有值被接收完毕后会自动退出循环。ps:如果没有关闭通道会死锁。

package main
import (
    "fmt"
    "sync"
)
var wg sync.WaitGroup
func f1(ch chan int){
  defer wg.Done()
  for x:=range ch{  //不断地从管道读取数据，直到管道被关闭，如果管道没有被关闭，会无法退出造成死锁
    fmt.Println(x)
  }
}
func main() {
  ch := make(chan int,10)
  wg.Add(1)
  go f1(ch)
  for i:=0;i<11;i++ {
    ch<-i
  }
  close(ch)    //这里不关闭管道会死锁
  wg.Wait()
}

当通道被关闭后，依旧可以从通道中读取数据，如果通道中已经没有数据那么会读到0值。

func main() {
  ch := make(chan int,2)
  ch<-10
  ch<-20
  close(ch)         
  //关闭管道后依然可以读到管道内的数据，for range只会读去管道存在的数据
  for x:=range ch { 
    fmt.Printf("x: %v\n", x)
  }
  //关闭了管道依然可以读，管道没有数据了，就会读到0值,ok==false
  x，ok:=<-ch
  fmt.Printf("x: %v\n", x)
  fmt.Printf("ok: %v\n", ok)
}

select

select可以从多个通道接收值，使用它可以同时响应多个通道的操作。

每个 case 分支会对应一个通道的通信（接收或发送）过程。select 会一直等待，直到其中的某个 case 的通信操作完成时，就会执行该 case 分支对应的语句。

select 具有以下特点：

可处理一个或多个 channel 的发送/接收操作。
如果多个 case 同时满足，select 会随机选择一个执行。

对于没有 case 的 select 会一直阻塞，可用于阻塞 main 函数，防止退出。

ch := make(chan int, 1)
for i := 1; i <= 10; i++ {
    select {  //select处理的是一个发送或者读取操作，如下对同一个管道的两个不同操作。
        case x := <-ch:
          fmt.Println(x)
        case ch <- i:
        }
}

select用于处理异步IO操作总结

1.select 会监听case语句中的读写操作，当case中的channel读写操作为非阻塞状态，将会触发相应的动作。

2.如果有多个case可以执行，select会随机公平地选出一个执行，其他不会执行。

3.如果没有可执行地case语句，且有default语句，就会执行default语句。

4.如果没有可运行地case语句，且没有default语句，select将阻塞，直到有case能执行。

2023-05-27 Go协程goroutine与通道channel